Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 6d3d3b83

History | View | Annotate | Download (146 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/pixdesc.h"
42
#include "libavutil/avstring.h"
43
#include "libavformat/os_support.h"
44

    
45
#if HAVE_SYS_RESOURCE_H
46
#include <sys/types.h>
47
#include <sys/time.h>
48
#include <sys/resource.h>
49
#elif HAVE_GETPROCESSTIMES
50
#include <windows.h>
51
#endif
52
#if HAVE_GETPROCESSMEMORYINFO
53
#include <windows.h>
54
#include <psapi.h>
55
#endif
56

    
57
#if HAVE_SYS_SELECT_H
58
#include <sys/select.h>
59
#endif
60

    
61
#if HAVE_TERMIOS_H
62
#include <fcntl.h>
63
#include <sys/ioctl.h>
64
#include <sys/time.h>
65
#include <termios.h>
66
#elif HAVE_CONIO_H
67
#include <conio.h>
68
#endif
69
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
70
#include <time.h>
71

    
72
#include "cmdutils.h"
73

    
74
#undef NDEBUG
75
#include <assert.h>
76

    
77
#undef exit
78

    
79
const char program_name[] = "FFmpeg";
80
const int program_birth_year = 2000;
81

    
82
/* select an input stream for an output stream */
83
typedef struct AVStreamMap {
84
    int file_index;
85
    int stream_index;
86
    int sync_file_index;
87
    int sync_stream_index;
88
} AVStreamMap;
89

    
90
/** select an input file for an output file */
91
typedef struct AVMetaDataMap {
92
    int out_file;
93
    int in_file;
94
} AVMetaDataMap;
95

    
96
static const OptionDef options[];
97

    
98
#define MAX_FILES 100
99

    
100
static const char *last_asked_format = NULL;
101
static AVFormatContext *input_files[MAX_FILES];
102
static int64_t input_files_ts_offset[MAX_FILES];
103
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
104
static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
105
static int nb_input_files = 0;
106
static int nb_icodecs;
107

    
108
static AVFormatContext *output_files[MAX_FILES];
109
static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
110
static int nb_output_files = 0;
111
static int nb_ocodecs;
112

    
113
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
114
static int nb_stream_maps;
115

    
116
static AVMetaDataMap meta_data_maps[MAX_FILES];
117
static int nb_meta_data_maps;
118

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

    
153
static int intra_only = 0;
154
static int audio_sample_rate = 44100;
155
static int64_t channel_layout = 0;
156
#define QSCALE_NONE -99999
157
static float audio_qscale = QSCALE_NONE;
158
static int audio_disable = 0;
159
static int audio_channels = 1;
160
static char  *audio_codec_name = NULL;
161
static int audio_codec_tag = 0;
162
static char *audio_language = NULL;
163

    
164
static int subtitle_disable = 0;
165
static char *subtitle_codec_name = NULL;
166
static char *subtitle_language = NULL;
167
static int subtitle_codec_tag = 0;
168

    
169
static float mux_preload= 0.5;
170
static float mux_max_delay= 0.7;
171

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

    
199
static int rate_emu = 0;
200

    
201
static int  video_channel = 0;
202
static char *video_standard;
203

    
204
static int audio_volume = 256;
205

    
206
static int exit_on_error = 0;
207
static int using_stdin = 0;
208
static int verbose = 1;
209
static int thread_count= 1;
210
static int q_pressed = 0;
211
static int64_t video_size = 0;
212
static int64_t audio_size = 0;
213
static int64_t extra_size = 0;
214
static int nb_frames_dup = 0;
215
static int nb_frames_drop = 0;
216
static int input_sync;
217
static uint64_t limit_filesize = 0;
218
static int force_fps = 0;
219

    
220
static int pgmyuv_compatibility_hack=0;
221
static float dts_delta_threshold = 10;
222

    
223
static unsigned int sws_flags = SWS_BICUBIC;
224

    
225
static int64_t timer_start;
226

    
227
static uint8_t *audio_buf;
228
static uint8_t *audio_out;
229
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
230

    
231
static short *samples;
232

    
233
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
234
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
235
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
236
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
237

    
238
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
239

    
240
struct AVInputStream;
241

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

    
262
    /* full frame size of first frame */
263
    int original_height;
264
    int original_width;
265

    
266
    /* cropping area sizes */
267
    int video_crop;
268
    int topBand;
269
    int bottomBand;
270
    int leftBand;
271
    int rightBand;
272

    
273
    /* cropping area of first frame */
274
    int original_topBand;
275
    int original_bottomBand;
276
    int original_leftBand;
277
    int original_rightBand;
278

    
279
    /* padding area sizes */
280
    int video_pad;
281
    int padtop;
282
    int padbottom;
283
    int padleft;
284
    int padright;
285

    
286
    /* audio only */
287
    int audio_resample;
288
    ReSampleContext *resample; /* for audio resampling */
289
    int reformat_pair;
290
    AVAudioConvert *reformat_ctx;
291
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
292
    FILE *logfile;
293
} AVOutputStream;
294

    
295
typedef struct AVInputStream {
296
    int file_index;
297
    int index;
298
    AVStream *st;
299
    int discard;             /* true if stream data should be discarded */
300
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
301
    int64_t sample_index;      /* current sample */
302

    
303
    int64_t       start;     /* time when read started */
304
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
305
                                is not defined */
306
    int64_t       pts;       /* current pts */
307
    int is_start;            /* is 1 at the start and after a discontinuity */
308
    int showed_multi_packet_warning;
309
    int is_past_recording_time;
310
} AVInputStream;
311

    
312
typedef struct AVInputFile {
313
    int eof_reached;      /* true if eof reached */
314
    int ist_index;        /* index of first stream in ist_table */
315
    int buffer_size;      /* current total buffer size */
316
    int nb_streams;       /* nb streams we are aware of */
317
} AVInputFile;
318

    
319
#if HAVE_TERMIOS_H
320

    
321
/* init terminal so that we can grab keys */
322
static struct termios oldtty;
323
#endif
324

    
325
static void term_exit(void)
326
{
327
#if HAVE_TERMIOS_H
328
    tcsetattr (0, TCSANOW, &oldtty);
329
#endif
330
}
331

    
332
static volatile int received_sigterm = 0;
333

    
334
static void
335
sigterm_handler(int sig)
336
{
337
    received_sigterm = sig;
338
    term_exit();
339
}
340

    
341
static void term_init(void)
342
{
343
#if HAVE_TERMIOS_H
344
    struct termios tty;
345

    
346
    tcgetattr (0, &tty);
347
    oldtty = tty;
348

    
349
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
350
                          |INLCR|IGNCR|ICRNL|IXON);
351
    tty.c_oflag |= OPOST;
352
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
353
    tty.c_cflag &= ~(CSIZE|PARENB);
354
    tty.c_cflag |= CS8;
355
    tty.c_cc[VMIN] = 1;
356
    tty.c_cc[VTIME] = 0;
357

    
358
    tcsetattr (0, TCSANOW, &tty);
359
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
360
#endif
361

    
362
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
363
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
364
#ifdef SIGXCPU
365
    signal(SIGXCPU, sigterm_handler);
366
#endif
367

    
368
    /*
369
    register a function to be called at normal program termination
370
    */
371
    atexit(term_exit);
372
#if CONFIG_BEOS_NETSERVER
373
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
374
#endif
375
}
376

    
377
/* read a key without blocking */
378
static int read_key(void)
379
{
380
#if HAVE_TERMIOS_H
381
    int n = 1;
382
    unsigned char ch;
383
#if !CONFIG_BEOS_NETSERVER
384
    struct timeval tv;
385
    fd_set rfds;
386

    
387
    FD_ZERO(&rfds);
388
    FD_SET(0, &rfds);
389
    tv.tv_sec = 0;
390
    tv.tv_usec = 0;
391
    n = select(1, &rfds, NULL, NULL, &tv);
392
#endif
393
    if (n > 0) {
394
        n = read(0, &ch, 1);
395
        if (n == 1)
396
            return ch;
397

    
398
        return n;
399
    }
400
#elif HAVE_CONIO_H
401
    if(kbhit())
402
        return(getch());
403
#endif
404
    return -1;
405
}
406

    
407
static int decode_interrupt_cb(void)
408
{
409
    return q_pressed || (q_pressed = read_key() == 'q');
410
}
411

    
412
static int av_exit(int ret)
413
{
414
    int i;
415

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

    
440
    av_free(intra_matrix);
441
    av_free(inter_matrix);
442

    
443
    if (vstats_file)
444
        fclose(vstats_file);
445
    av_free(vstats_filename);
446

    
447
    av_free(opt_names);
448

    
449
    av_free(video_codec_name);
450
    av_free(audio_codec_name);
451
    av_free(subtitle_codec_name);
452

    
453
    av_free(video_standard);
454

    
455
#if CONFIG_POWERPC_PERF
456
    void powerpc_display_perf_report(void);
457
    powerpc_display_perf_report();
458
#endif /* CONFIG_POWERPC_PERF */
459

    
460
    for (i=0;i<CODEC_TYPE_NB;i++)
461
        av_free(avcodec_opts[i]);
462
    av_free(avformat_opts);
463
    av_free(sws_opts);
464
    av_free(audio_buf);
465
    av_free(audio_out);
466
    allocated_audio_buf_size= allocated_audio_out_size= 0;
467
    av_free(samples);
468

    
469
    if (received_sigterm) {
470
        fprintf(stderr,
471
            "Received signal %d: terminating.\n",
472
            (int) received_sigterm);
473
        exit (255);
474
    }
475

    
476
    exit(ret); /* not all OS-es handle main() return value */
477
    return ret;
478
}
479

    
480
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
481
{
482
    int i, err;
483
    AVFormatContext *ic;
484
    int nopts = 0;
485

    
486
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
487
    if (err < 0)
488
        return err;
489
    /* copy stream format */
490
    s->nb_streams = ic->nb_streams;
491
    for(i=0;i<ic->nb_streams;i++) {
492
        AVStream *st;
493

    
494
        // FIXME: a more elegant solution is needed
495
        st = av_mallocz(sizeof(AVStream));
496
        memcpy(st, ic->streams[i], sizeof(AVStream));
497
        st->codec = avcodec_alloc_context();
498
        if (!st->codec) {
499
            print_error(filename, AVERROR(ENOMEM));
500
            av_exit(1);
501
        }
502
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
503
        s->streams[i] = st;
504

    
505
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
506
            st->stream_copy = 1;
507
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
508
            st->stream_copy = 1;
509

    
510
        if(!st->codec->thread_count)
511
            st->codec->thread_count = 1;
512
        if(st->codec->thread_count>1)
513
            avcodec_thread_init(st->codec, st->codec->thread_count);
514

    
515
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
516
            nopts = 1;
517
    }
518

    
519
    if (!nopts)
520
        s->timestamp = av_gettime();
521

    
522
    av_close_input_file(ic);
523
    return 0;
524
}
525

    
526
static double
527
get_sync_ipts(const AVOutputStream *ost)
528
{
529
    const AVInputStream *ist = ost->sync_ist;
530
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
531
}
532

    
533
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
534
    int ret;
535

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

    
555
        bsfc= bsfc->next;
556
    }
557

    
558
    ret= av_interleaved_write_frame(s, pkt);
559
    if(ret < 0){
560
        print_error("av_interleaved_write_frame()", ret);
561
        av_exit(1);
562
    }
563
}
564

    
565
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
566

    
567
static void do_audio_out(AVFormatContext *s,
568
                         AVOutputStream *ost,
569
                         AVInputStream *ist,
570
                         unsigned char *buf, int size)
571
{
572
    uint8_t *buftmp;
573
    int64_t audio_out_size, audio_buf_size;
574
    int64_t allocated_for_size= size;
575

    
576
    int size_out, frame_bytes, ret;
577
    AVCodecContext *enc= ost->st->codec;
578
    AVCodecContext *dec= ist->st->codec;
579
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
580
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
581
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
582

    
583
need_realloc:
584
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
585
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
586
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
587
    audio_buf_size*= osize*enc->channels;
588

    
589
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
590
    if(coded_bps > 8*osize)
591
        audio_out_size= audio_out_size * coded_bps / (8*osize);
592
    audio_out_size += FF_MIN_BUFFER_SIZE;
593

    
594
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
595
        fprintf(stderr, "Buffer sizes too large\n");
596
        av_exit(1);
597
    }
598

    
599
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
600
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
601
    if (!audio_buf || !audio_out){
602
        fprintf(stderr, "Out of memory in do_audio_out\n");
603
        av_exit(1);
604
    }
605

    
606
    if (enc->channels != dec->channels)
607
        ost->audio_resample = 1;
608

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

    
624
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
625
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
626
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
627
        if (ost->reformat_ctx)
628
            av_audio_convert_free(ost->reformat_ctx);
629
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
630
                                                   dec->sample_fmt, 1, NULL, 0);
631
        if (!ost->reformat_ctx) {
632
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
633
                avcodec_get_sample_fmt_name(dec->sample_fmt),
634
                avcodec_get_sample_fmt_name(enc->sample_fmt));
635
            av_exit(1);
636
        }
637
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
638
    }
639

    
640
    if(audio_sync_method){
641
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
642
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
643
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
644
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
645

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

    
662
                    if(byte_delta > allocated_for_size - size){
663
                        allocated_for_size= byte_delta + (int64_t)size;
664
                        goto need_realloc;
665
                    }
666
                    ist->is_start=0;
667

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

    
688
    if (ost->audio_resample) {
689
        buftmp = audio_buf;
690
        size_out = audio_resample(ost->resample,
691
                                  (short *)buftmp, (short *)buf,
692
                                  size / (ist->st->codec->channels * isize));
693
        size_out = size_out * enc->channels * osize;
694
    } else {
695
        buftmp = buf;
696
        size_out = size;
697
    }
698

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

    
715
    /* now encode as many frames as possible */
716
    if (enc->frame_size > 1) {
717
        /* output resampled raw samples */
718
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
719
            fprintf(stderr, "av_fifo_realloc2() failed\n");
720
            av_exit(1);
721
        }
722
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
723

    
724
        frame_bytes = enc->frame_size * osize * enc->channels;
725

    
726
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
727
            AVPacket pkt;
728
            av_init_packet(&pkt);
729

    
730
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
731

    
732
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
733

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

    
749
            ost->sync_opts += enc->frame_size;
750
        }
751
    } else {
752
        AVPacket pkt;
753
        av_init_packet(&pkt);
754

    
755
        ost->sync_opts += size_out / (osize * enc->channels);
756

    
757
        /* output a pcm frame */
758
        /* determine the size of the coded buffer */
759
        size_out /= osize;
760
        if (coded_bps)
761
            size_out = size_out*coded_bps/8;
762

    
763
        if(size_out > audio_out_size){
764
            fprintf(stderr, "Internal error, buffer size too small\n");
765
            av_exit(1);
766
        }
767

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

    
786
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
787
{
788
    AVCodecContext *dec;
789
    AVPicture *picture2;
790
    AVPicture picture_tmp;
791
    uint8_t *buf = 0;
792

    
793
    dec = ist->st->codec;
794

    
795
    /* deinterlace : must be done before any resize */
796
    if (do_deinterlace) {
797
        int size;
798

    
799
        /* create temporary picture */
800
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
801
        buf = av_malloc(size);
802
        if (!buf)
803
            return;
804

    
805
        picture2 = &picture_tmp;
806
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
807

    
808
        if(avpicture_deinterlace(picture2, picture,
809
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
810
            /* if error, do not deinterlace */
811
            fprintf(stderr, "Deinterlacing failed\n");
812
            av_free(buf);
813
            buf = NULL;
814
            picture2 = picture;
815
        }
816
    } else {
817
        picture2 = picture;
818
    }
819

    
820
    if (picture != picture2)
821
        *picture = *picture2;
822
    *bufp = buf;
823
}
824

    
825
/* we begin to correct av delay at this threshold */
826
#define AV_DELAY_MAX 0.100
827

    
828
static void do_subtitle_out(AVFormatContext *s,
829
                            AVOutputStream *ost,
830
                            AVInputStream *ist,
831
                            AVSubtitle *sub,
832
                            int64_t pts)
833
{
834
    static uint8_t *subtitle_out = NULL;
835
    int subtitle_out_max_size = 1024 * 1024;
836
    int subtitle_out_size, nb, i;
837
    AVCodecContext *enc;
838
    AVPacket pkt;
839

    
840
    if (pts == AV_NOPTS_VALUE) {
841
        fprintf(stderr, "Subtitle packets must have a pts\n");
842
        if (exit_on_error)
843
            av_exit(1);
844
        return;
845
    }
846

    
847
    enc = ost->st->codec;
848

    
849
    if (!subtitle_out) {
850
        subtitle_out = av_malloc(subtitle_out_max_size);
851
    }
852

    
853
    /* Note: DVB subtitle need one packet to draw them and one other
854
       packet to clear them */
855
    /* XXX: signal it in the codec context ? */
856
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
857
        nb = 2;
858
    else
859
        nb = 1;
860

    
861
    for(i = 0; i < nb; i++) {
862
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
863
        // start_display_time is required to be 0
864
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
865
        sub->end_display_time -= sub->start_display_time;
866
        sub->start_display_time = 0;
867
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
868
                                                    subtitle_out_max_size, sub);
869
        if (subtitle_out_size < 0) {
870
            fprintf(stderr, "Subtitle encoding failed\n");
871
            av_exit(1);
872
        }
873

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

    
891
static int bit_buffer_size= 1024*256;
892
static uint8_t *bit_buffer= NULL;
893

    
894
static void do_video_out(AVFormatContext *s,
895
                         AVOutputStream *ost,
896
                         AVInputStream *ist,
897
                         AVFrame *in_picture,
898
                         int *frame_size)
899
{
900
    int nb_frames, i, ret;
901
    int64_t topBand, bottomBand, leftBand, rightBand;
902
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
903
    AVFrame picture_crop_temp, picture_pad_temp;
904
    AVCodecContext *enc, *dec;
905

    
906
    avcodec_get_frame_defaults(&picture_crop_temp);
907
    avcodec_get_frame_defaults(&picture_pad_temp);
908

    
909
    enc = ost->st->codec;
910
    dec = ist->st->codec;
911

    
912
    /* by default, we output a single frame */
913
    nb_frames = 1;
914

    
915
    *frame_size = 0;
916

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

    
943
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
944
    if (nb_frames <= 0)
945
        return;
946

    
947
    if (ost->video_crop) {
948
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
949
            fprintf(stderr, "error cropping picture\n");
950
            if (exit_on_error)
951
                av_exit(1);
952
            return;
953
        }
954
        formatted_picture = &picture_crop_temp;
955
    } else {
956
        formatted_picture = in_picture;
957
    }
958

    
959
    final_picture = formatted_picture;
960
    padding_src = formatted_picture;
961
    resampling_dst = &ost->pict_tmp;
962
    if (ost->video_pad) {
963
        final_picture = &ost->pict_tmp;
964
        if (ost->video_resample) {
965
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
966
                fprintf(stderr, "error padding picture\n");
967
                if (exit_on_error)
968
                    av_exit(1);
969
                return;
970
            }
971
            resampling_dst = &picture_pad_temp;
972
        }
973
    }
974

    
975
    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
976
        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
977
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
978

    
979
        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));
980
        if(!ost->video_resample)
981
            av_exit(1);
982
    }
983

    
984
    if (ost->video_resample) {
985
        padding_src = NULL;
986
        final_picture = &ost->pict_tmp;
987
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
988
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
989
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
990

    
991
            /* keep bands proportional to the frame size */
992
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
993
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
994
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
995
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
996

    
997
            /* sanity check to ensure no bad band sizes sneak in */
998
            assert(topBand    <= INT_MAX && topBand    >= 0);
999
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
1000
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
1001
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
1002

    
1003
            ost->topBand    = topBand;
1004
            ost->bottomBand = bottomBand;
1005
            ost->leftBand   = leftBand;
1006
            ost->rightBand  = rightBand;
1007

    
1008
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
1009
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
1010
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1011

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

    
1032
    if (ost->video_pad) {
1033
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1034
                enc->height, enc->width, enc->pix_fmt,
1035
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1036
    }
1037

    
1038
    /* duplicates frame if needed */
1039
    for(i=0;i<nb_frames;i++) {
1040
        AVPacket pkt;
1041
        av_init_packet(&pkt);
1042
        pkt.stream_index= ost->index;
1043

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

    
1055
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1056
            enc->coded_frame = old_frame;
1057
        } else {
1058
            AVFrame big_picture;
1059

    
1060
            big_picture= *final_picture;
1061
            /* better than nothing: use input picture interlaced
1062
               settings */
1063
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1064
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1065
                if(top_field_first == -1)
1066
                    big_picture.top_field_first = in_picture->top_field_first;
1067
                else
1068
                    big_picture.top_field_first = top_field_first;
1069
            }
1070

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

    
1091
            if(ret>0){
1092
                pkt.data= bit_buffer;
1093
                pkt.size= ret;
1094
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1095
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1096
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1097
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1098
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1099

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

    
1118
static double psnr(double d){
1119
    return -10.0*log(d)/log(10.0);
1120
}
1121

    
1122
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1123
                           int frame_size)
1124
{
1125
    AVCodecContext *enc;
1126
    int frame_number;
1127
    double ti1, bitrate, avg_bitrate;
1128

    
1129
    /* this is executed just the first time do_video_stats is called */
1130
    if (!vstats_file) {
1131
        vstats_file = fopen(vstats_filename, "w");
1132
        if (!vstats_file) {
1133
            perror("fopen");
1134
            av_exit(1);
1135
        }
1136
    }
1137

    
1138
    enc = ost->st->codec;
1139
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1140
        frame_number = ost->frame_number;
1141
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1142
        if (enc->flags&CODEC_FLAG_PSNR)
1143
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1144

    
1145
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1146
        /* compute pts value */
1147
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1148
        if (ti1 < 0.01)
1149
            ti1 = 0.01;
1150

    
1151
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1152
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1153
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1154
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1155
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1156
    }
1157
}
1158

    
1159
static void print_report(AVFormatContext **output_files,
1160
                         AVOutputStream **ost_table, int nb_ostreams,
1161
                         int is_last_report)
1162
{
1163
    char buf[1024];
1164
    AVOutputStream *ost;
1165
    AVFormatContext *oc;
1166
    int64_t total_size;
1167
    AVCodecContext *enc;
1168
    int frame_number, vid, i;
1169
    double bitrate, ti1, pts;
1170
    static int64_t last_time = -1;
1171
    static int qp_histogram[52];
1172

    
1173
    if (!is_last_report) {
1174
        int64_t cur_time;
1175
        /* display the report every 0.5 seconds */
1176
        cur_time = av_gettime();
1177
        if (last_time == -1) {
1178
            last_time = cur_time;
1179
            return;
1180
        }
1181
        if ((cur_time - last_time) < 500000)
1182
            return;
1183
        last_time = cur_time;
1184
    }
1185

    
1186

    
1187
    oc = output_files[0];
1188

    
1189
    total_size = url_fsize(oc->pb);
1190
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1191
        total_size= url_ftell(oc->pb);
1192

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

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

    
1253
    if (verbose || is_last_report) {
1254
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1255

    
1256
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1257
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1258
            (double)total_size / 1024, ti1, bitrate);
1259

    
1260
        if (nb_frames_dup || nb_frames_drop)
1261
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1262
                  nb_frames_dup, nb_frames_drop);
1263

    
1264
        if (verbose >= 0)
1265
            fprintf(stderr, "%s    \r", buf);
1266

    
1267
        fflush(stderr);
1268
    }
1269

    
1270
    if (is_last_report && verbose >= 0){
1271
        int64_t raw= audio_size + video_size + extra_size;
1272
        fprintf(stderr, "\n");
1273
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1274
                video_size/1024.0,
1275
                audio_size/1024.0,
1276
                extra_size/1024.0,
1277
                100.0*(total_size - raw)/raw
1278
        );
1279
    }
1280
}
1281

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

    
1299
    if(ist->next_pts == AV_NOPTS_VALUE)
1300
        ist->next_pts= ist->pts;
1301

    
1302
    if (pkt == NULL) {
1303
        /* EOF handling */
1304
        av_init_packet(&avpkt);
1305
        avpkt.data = NULL;
1306
        avpkt.size = 0;
1307
        goto handle_eof;
1308
    } else {
1309
        avpkt = *pkt;
1310
    }
1311

    
1312
    if(pkt->dts != AV_NOPTS_VALUE)
1313
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1314

    
1315
    //while we have more to decode or while the decoder did output something on EOF
1316
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1317
        uint8_t *data_buf, *decoded_data_buf;
1318
        int data_size, decoded_data_size;
1319
    handle_eof:
1320
        ist->pts= ist->next_pts;
1321

    
1322
        if(avpkt.size && avpkt.size != pkt->size &&
1323
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1324
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1325
            ist->showed_multi_packet_warning=1;
1326
        }
1327

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

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

    
1417
        buffer_to_free = NULL;
1418
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1419
            pre_process_video_frame(ist, (AVPicture *)&picture,
1420
                                    &buffer_to_free);
1421
        }
1422

    
1423
        // preprocess audio (volume)
1424
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1425
            if (audio_volume != 256) {
1426
                short *volp;
1427
                volp = samples;
1428
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1429
                    int v = ((*volp) * audio_volume + 128) >> 8;
1430
                    if (v < -32768) v = -32768;
1431
                    if (v >  32767) v = 32767;
1432
                    *volp++ = v;
1433
                }
1434
            }
1435
        }
1436

    
1437
        /* frame rate emulation */
1438
        if (rate_emu) {
1439
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1440
            int64_t now = av_gettime() - ist->start;
1441
            if (pts > now)
1442
                usleep(pts - now);
1443
        }
1444

    
1445
        /* if output time reached then transcode raw format,
1446
           encode packets and output them */
1447
        if (start_time == 0 || ist->pts >= start_time)
1448
            for(i=0;i<nb_ostreams;i++) {
1449
                int frame_size;
1450

    
1451
                ost = ost_table[i];
1452
                if (ost->source_index == ist_index) {
1453
                    os = output_files[ost->file_index];
1454

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

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

    
1481
                        av_init_packet(&opkt);
1482

    
1483
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1484
                            continue;
1485

    
1486
                        /* no reencoding needed : output the packet directly */
1487
                        /* force the input stream PTS */
1488

    
1489
                        avcodec_get_frame_defaults(&avframe);
1490
                        ost->st->codec->coded_frame= &avframe;
1491
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1492

    
1493
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1494
                            audio_size += data_size;
1495
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1496
                            video_size += data_size;
1497
                            ost->sync_opts++;
1498
                        }
1499

    
1500
                        opkt.stream_index= ost->index;
1501
                        if(pkt->pts != AV_NOPTS_VALUE)
1502
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1503
                        else
1504
                            opkt.pts= AV_NOPTS_VALUE;
1505

    
1506
                        if (pkt->dts == AV_NOPTS_VALUE)
1507
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1508
                        else
1509
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1510
                        opkt.dts -= ost_tb_start_time;
1511

    
1512
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1513
                        opkt.flags= pkt->flags;
1514

    
1515
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1516
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1517
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1518
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1519
                           ) {
1520
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1521
                                opkt.destruct= av_destruct_packet;
1522
                        } else {
1523
                            opkt.data = data_buf;
1524
                            opkt.size = data_size;
1525
                        }
1526

    
1527
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1528
                        ost->st->codec->frame_number++;
1529
                        ost->frame_number++;
1530
                        av_free_packet(&opkt);
1531
                    }
1532
                }
1533
            }
1534
        av_free(buffer_to_free);
1535
        /* XXX: allocate the subtitles in the codec ? */
1536
        if (subtitle_to_free) {
1537
            if (subtitle_to_free->rects != NULL) {
1538
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1539
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1540
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1541
                    av_freep(&subtitle_to_free->rects[i]);
1542
                }
1543
                av_freep(&subtitle_to_free->rects);
1544
            }
1545
            subtitle_to_free->num_rects = 0;
1546
            subtitle_to_free = NULL;
1547
        }
1548
    }
1549
 discard_packet:
1550
    if (pkt == NULL) {
1551
        /* EOF handling */
1552

    
1553
        for(i=0;i<nb_ostreams;i++) {
1554
            ost = ost_table[i];
1555
            if (ost->source_index == ist_index) {
1556
                AVCodecContext *enc= ost->st->codec;
1557
                os = output_files[ost->file_index];
1558

    
1559
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1560
                    continue;
1561
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1562
                    continue;
1563

    
1564
                if (ost->encoding_needed) {
1565
                    for(;;) {
1566
                        AVPacket pkt;
1567
                        int fifo_bytes;
1568
                        av_init_packet(&pkt);
1569
                        pkt.stream_index= ost->index;
1570

    
1571
                        switch(ost->st->codec->codec_type) {
1572
                        case CODEC_TYPE_AUDIO:
1573
                            fifo_bytes = av_fifo_size(ost->fifo);
1574
                            ret = 0;
1575
                            /* encode any samples remaining in fifo */
1576
                            if (fifo_bytes > 0) {
1577
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1578
                                int fs_tmp = enc->frame_size;
1579

    
1580
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1581
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1582
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1583
                                } else { /* pad */
1584
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1585
                                    if (samples_size < frame_bytes)
1586
                                        av_exit(1);
1587
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1588
                                }
1589

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

    
1622
                        if(ret<=0)
1623
                            break;
1624
                        pkt.data= bit_buffer;
1625
                        pkt.size= ret;
1626
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1627
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1628
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1629
                    }
1630
                }
1631
            }
1632
        }
1633
    }
1634

    
1635
    return 0;
1636
 fail_decode:
1637
    return -1;
1638
}
1639

    
1640
static void print_sdp(AVFormatContext **avc, int n)
1641
{
1642
    char sdp[2048];
1643

    
1644
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1645
    printf("SDP:\n%s\n", sdp);
1646
    fflush(stdout);
1647
}
1648

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

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

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

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

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

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

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

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

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

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

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

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

    
1779
            } else {
1780
                    /* get corresponding input stream index : we select the first one with the right type */
1781
                    found = 0;
1782
                    for(j=0;j<nb_istreams;j++) {
1783
                        int skip=0;
1784
                        ist = ist_table[j];
1785
                        if(opt_programid){
1786
                            int pi,si;
1787
                            AVFormatContext *f= input_files[ ist->file_index ];
1788
                            skip=1;
1789
                            for(pi=0; pi<f->nb_programs; pi++){
1790
                                AVProgram *p= f->programs[pi];
1791
                                if(p->id == opt_programid)
1792
                                    for(si=0; si<p->nb_stream_indexes; si++){
1793
                                        if(f->streams[ p->stream_index[si] ] == ist->st)
1794
                                            skip=0;
1795
                                    }
1796
                            }
1797
                        }
1798
                        if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
1799
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1800
                            ost->source_index = j;
1801
                            found = 1;
1802
                            break;
1803
                        }
1804
                    }
1805

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2120

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

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

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

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

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

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

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

    
2181
    timer_start = av_gettime();
2182

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

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

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

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

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

    
2260
        no_packet_count=0;
2261
        memset(no_packet, 0, sizeof(no_packet));
2262

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

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

    
2280
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2281
            if(pkt.pts != AV_NOPTS_VALUE)
2282
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2283
            if(pkt.dts != AV_NOPTS_VALUE)
2284
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2285
        }
2286

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

    
2302
        /* finish if recording time exhausted */
2303
        if (av_compare_ts(pkt.pts, ist->st->time_base, recording_time, (AVRational){1, 1000000}) >= 0) {
2304
            ist->is_past_recording_time = 1;
2305
            goto discard_packet;
2306
        }
2307

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

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

    
2320
    discard_packet:
2321
        av_free_packet(&pkt);
2322

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

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

    
2335
    term_exit();
2336

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

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

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

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

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

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

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

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

    
2412
    last_asked_format = arg;
2413
}
2414

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

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

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

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

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

    
2445
    opt_default(opt, arg);
2446

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

    
2450
    return 0;
2451
}
2452

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

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

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

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

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

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

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

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

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

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

    
2550

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

    
2560

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

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

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

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

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

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

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

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

    
2623
    return 0;
2624
}
2625

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2875
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2876

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

    
2882
    if(pgmyuv_compatibility_hack)
2883
        ic->video_codec_id= CODEC_ID_PGMYUV;
2884

    
2885
    /* open the input file with generic libav function */
2886
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2887
    if (err < 0) {
2888
        print_error(filename, err);
2889
        av_exit(1);
2890
    }
2891
    if(opt_programid) {
2892
        int i, j;
2893
        int found=0;
2894
        for(i=0; i<ic->nb_streams; i++){
2895
            ic->streams[i]->discard= AVDISCARD_ALL;
2896
        }
2897
        for(i=0; i<ic->nb_programs; i++){
2898
            AVProgram *p= ic->programs[i];
2899
            if(p->id != opt_programid){
2900
                p->discard = AVDISCARD_ALL;
2901
            }else{
2902
                found=1;
2903
                for(j=0; j<p->nb_stream_indexes; j++){
2904
                    ic->streams[p->stream_index[j]]->discard= 0;
2905
                }
2906
            }
2907
        }
2908
        if(!found){
2909
            fprintf(stderr, "Specified program id not found\n");
2910
            av_exit(1);
2911
        }
2912
        opt_programid=0;
2913
    }
2914

    
2915
    ic->loop_input = loop_input;
2916

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

    
2925
    timestamp = start_time;
2926
    /* add the stream start time */
2927
    if (ic->start_time != AV_NOPTS_VALUE)
2928
        timestamp += ic->start_time;
2929

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

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

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

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

    
2984
                    (float)rfps / rfps_base, rfps, rfps_base);
2985
            }
2986
            /* update the current frame rate to match the stream frame rate */
2987
            frame_rate.num = rfps;
2988
            frame_rate.den = rfps_base;
2989

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

    
3012
    input_files[nb_input_files] = ic;
3013
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3014
    /* dump the file content */
3015
    if (verbose >= 0)
3016
        dump_format(ic, nb_input_files, filename, 0);
3017

    
3018
    nb_input_files++;
3019

    
3020
    video_channel = 0;
3021

    
3022
    av_freep(&video_codec_name);
3023
    av_freep(&audio_codec_name);
3024
    av_freep(&subtitle_codec_name);
3025
}
3026

    
3027
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3028
                                         int *has_subtitle_ptr)
3029
{
3030
    int has_video, has_audio, has_subtitle, i, j;
3031
    AVFormatContext *ic;
3032

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

    
3064
static void new_video_stream(AVFormatContext *oc)
3065
{
3066
    AVStream *st;
3067
    AVCodecContext *video_enc;
3068
    enum CodecID codec_id;
3069

    
3070
    st = av_new_stream(oc, oc->nb_streams);
3071
    if (!st) {
3072
        fprintf(stderr, "Could not alloc stream\n");
3073
        av_exit(1);
3074
    }
3075
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3076
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3077
    video_bitstream_filters= NULL;
3078

    
3079
    avcodec_thread_init(st->codec, thread_count);
3080

    
3081
    video_enc = st->codec;
3082

    
3083
    if(video_codec_tag)
3084
        video_enc->codec_tag= video_codec_tag;
3085

    
3086
    if(   (video_global_header&1)
3087
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3088
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3089
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3090
    }
3091
    if(video_global_header&2){
3092
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3093
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3094
    }
3095

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

    
3107
        if (video_codec_name) {
3108
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3109
            codec = avcodec_find_encoder_by_name(video_codec_name);
3110
            output_codecs[nb_ocodecs] = codec;
3111
        } else {
3112
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3113
            codec = avcodec_find_encoder(codec_id);
3114
        }
3115

    
3116
        video_enc->codec_id = codec_id;
3117

    
3118
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3119

    
3120
        if (codec && codec->supported_framerates && !force_fps)
3121
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3122
        video_enc->time_base.den = fps.num;
3123
        video_enc->time_base.num = fps.den;
3124

    
3125
        video_enc->width = frame_width + frame_padright + frame_padleft;
3126
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3127
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3128
        video_enc->pix_fmt = frame_pix_fmt;
3129
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3130

    
3131
        if(codec && codec->pix_fmts){
3132
            const enum PixelFormat *p= codec->pix_fmts;
3133
            for(; *p!=-1; p++){
3134
                if(*p == video_enc->pix_fmt)
3135
                    break;
3136
            }
3137
            if(*p == -1)
3138
                video_enc->pix_fmt = codec->pix_fmts[0];
3139
        }
3140

    
3141
        if (intra_only)
3142
            video_enc->gop_size = 0;
3143
        if (video_qscale || same_quality) {
3144
            video_enc->flags |= CODEC_FLAG_QSCALE;
3145
            video_enc->global_quality=
3146
                st->quality = FF_QP2LAMBDA * video_qscale;
3147
        }
3148

    
3149
        if(intra_matrix)
3150
            video_enc->intra_matrix = intra_matrix;
3151
        if(inter_matrix)
3152
            video_enc->inter_matrix = inter_matrix;
3153

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

    
3184
        if (do_psnr)
3185
            video_enc->flags|= CODEC_FLAG_PSNR;
3186

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

    
3202
    /* reset some key parameters */
3203
    video_disable = 0;
3204
    av_freep(&video_codec_name);
3205
    video_stream_copy = 0;
3206
}
3207

    
3208
static void new_audio_stream(AVFormatContext *oc)
3209
{
3210
    AVStream *st;
3211
    AVCodecContext *audio_enc;
3212
    enum CodecID codec_id;
3213

    
3214
    st = av_new_stream(oc, oc->nb_streams);
3215
    if (!st) {
3216
        fprintf(stderr, "Could not alloc stream\n");
3217
        av_exit(1);
3218
    }
3219
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3220

    
3221
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3222
    audio_bitstream_filters= NULL;
3223

    
3224
    avcodec_thread_init(st->codec, thread_count);
3225

    
3226
    audio_enc = st->codec;
3227
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3228

    
3229
    if(audio_codec_tag)
3230
        audio_enc->codec_tag= audio_codec_tag;
3231

    
3232
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3233
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3234
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3235
    }
3236
    if (audio_stream_copy) {
3237
        st->stream_copy = 1;
3238
        audio_enc->channels = audio_channels;
3239
    } else {
3240
        AVCodec *codec;
3241

    
3242
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3243

    
3244
        if (audio_codec_name) {
3245
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3246
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3247
            output_codecs[nb_ocodecs] = codec;
3248
        } else {
3249
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3250
            codec = avcodec_find_encoder(codec_id);
3251
        }
3252
        audio_enc->codec_id = codec_id;
3253

    
3254
        if (audio_qscale > QSCALE_NONE) {
3255
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3256
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3257
        }
3258
        audio_enc->channels = audio_channels;
3259
        audio_enc->sample_fmt = audio_sample_fmt;
3260
        audio_enc->channel_layout = channel_layout;
3261
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3262
            audio_enc->channel_layout = 0;
3263

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

    
3282
    /* reset some key parameters */
3283
    audio_disable = 0;
3284
    av_freep(&audio_codec_name);
3285
    audio_stream_copy = 0;
3286
}
3287

    
3288
static void new_subtitle_stream(AVFormatContext *oc)
3289
{
3290
    AVStream *st;
3291
    AVCodecContext *subtitle_enc;
3292

    
3293
    st = av_new_stream(oc, oc->nb_streams);
3294
    if (!st) {
3295
        fprintf(stderr, "Could not alloc stream\n");
3296
        av_exit(1);
3297
    }
3298
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3299

    
3300
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3301
    subtitle_bitstream_filters= NULL;
3302

    
3303
    subtitle_enc = st->codec;
3304
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3305

    
3306
    if(subtitle_codec_tag)
3307
        subtitle_enc->codec_tag= subtitle_codec_tag;
3308

    
3309
    if (subtitle_stream_copy) {
3310
        st->stream_copy = 1;
3311
    } else {
3312
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3313
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3314
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3315
    }
3316
    nb_ocodecs++;
3317

    
3318
    if (subtitle_language) {
3319
        av_metadata_set(&st->metadata, "language", subtitle_language);
3320
        av_freep(&subtitle_language);
3321
    }
3322

    
3323
    subtitle_disable = 0;
3324
    av_freep(&subtitle_codec_name);
3325
    subtitle_stream_copy = 0;
3326
}
3327

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

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

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

    
3361
static void opt_output_file(const char *filename)
3362
{
3363
    AVFormatContext *oc;
3364
    int use_video, use_audio, use_subtitle;
3365
    int input_has_video, input_has_audio, input_has_subtitle;
3366
    AVFormatParameters params, *ap = &params;
3367
    AVOutputFormat *file_oformat;
3368

    
3369
    if (!strcmp(filename, "-"))
3370
        filename = "pipe:";
3371

    
3372
    oc = avformat_alloc_context();
3373
    if (!oc) {
3374
        print_error(filename, AVERROR(ENOMEM));
3375
        av_exit(1);
3376
    }
3377

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

    
3394
    oc->oformat = file_oformat;
3395
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3396

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

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

    
3424
        /* manual disable */
3425
        if (audio_disable) {
3426
            use_audio = 0;
3427
        }
3428
        if (video_disable) {
3429
            use_video = 0;
3430
        }
3431
        if (subtitle_disable) {
3432
            use_subtitle = 0;
3433
        }
3434

    
3435
        if (use_video) {
3436
            new_video_stream(oc);
3437
        }
3438

    
3439
        if (use_audio) {
3440
            new_audio_stream(oc);
3441
        }
3442

    
3443
        if (use_subtitle) {
3444
            new_subtitle_stream(oc);
3445
        }
3446

    
3447
        oc->timestamp = rec_timestamp;
3448

    
3449
        for(; metadata_count>0; metadata_count--){
3450
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3451
                                           metadata[metadata_count-1].value);
3452
        }
3453
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3454
    }
3455

    
3456
    output_files[nb_output_files++] = oc;
3457

    
3458
    /* check filename in case of an image number is expected */
3459
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3460
        if (!av_filename_number_test(oc->filename)) {
3461
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3462
            av_exit(1);
3463
        }
3464
    }
3465

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

    
3488
        /* open the file */
3489
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3490
            fprintf(stderr, "Could not open '%s'\n", filename);
3491
            av_exit(1);
3492
        }
3493
    }
3494

    
3495
    memset(ap, 0, sizeof(*ap));
3496
    if (av_set_parameters(oc, ap) < 0) {
3497
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3498
                oc->filename);
3499
        av_exit(1);
3500
    }
3501

    
3502
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3503
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3504
    oc->loop_output = loop_output;
3505
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3506

    
3507
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3508
}
3509

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

    
3522
static int64_t getutime(void)
3523
{
3524
#if HAVE_GETRUSAGE
3525
    struct rusage rusage;
3526

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

    
3540
static int64_t getmaxrss(void)
3541
{
3542
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3543
    struct rusage rusage;
3544
    getrusage(RUSAGE_SELF, &rusage);
3545
    return (int64_t)rusage.ru_maxrss * 1024;
3546
#elif HAVE_GETPROCESSMEMORYINFO
3547
    HANDLE proc;
3548
    PROCESS_MEMORY_COUNTERS memcounters;
3549
    proc = GetCurrentProcess();
3550
    memcounters.cb = sizeof(memcounters);
3551
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3552
    return memcounters.PeakPagefileUsage;
3553
#else
3554
    return 0;
3555
#endif
3556
}
3557

    
3558
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3559
{
3560
    int i;
3561
    const char *p = str;
3562
    for(i = 0;; i++) {
3563
        dest[i] = atoi(p);
3564
        if(i == 63)
3565
            break;
3566
        p = strchr(p, ',');
3567
        if(!p) {
3568
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3569
            av_exit(1);
3570
        }
3571
        p++;
3572
    }
3573
}
3574

    
3575
static void opt_inter_matrix(const char *arg)
3576
{
3577
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3578
    parse_matrix_coeffs(inter_matrix, arg);
3579
}
3580

    
3581
static void opt_intra_matrix(const char *arg)
3582
{
3583
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3584
    parse_matrix_coeffs(intra_matrix, arg);
3585
}
3586

    
3587
/**
3588
 * Trivial log callback.
3589
 * Only suitable for show_help and similar since it lacks prefix handling.
3590
 */
3591
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3592
{
3593
    vfprintf(stdout, fmt, vl);
3594
}
3595

    
3596
static void show_usage(void)
3597
{
3598
    printf("Hyper fast Audio and Video encoder\n");
3599
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3600
    printf("\n");
3601
}
3602

    
3603
static void show_help(void)
3604
{
3605
    av_log_set_callback(log_callback_help);
3606
    show_usage();
3607
    show_help_options(options, "Main options:\n",
3608
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3609
    show_help_options(options, "\nAdvanced options:\n",
3610
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3611
                      OPT_EXPERT);
3612
    show_help_options(options, "\nVideo options:\n",
3613
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3614
                      OPT_VIDEO);
3615
    show_help_options(options, "\nAdvanced Video options:\n",
3616
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3617
                      OPT_VIDEO | OPT_EXPERT);
3618
    show_help_options(options, "\nAudio options:\n",
3619
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3620
                      OPT_AUDIO);
3621
    show_help_options(options, "\nAdvanced Audio options:\n",
3622
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3623
                      OPT_AUDIO | OPT_EXPERT);
3624
    show_help_options(options, "\nSubtitle options:\n",
3625
                      OPT_SUBTITLE | OPT_GRAB,
3626
                      OPT_SUBTITLE);
3627
    show_help_options(options, "\nAudio/Video grab options:\n",
3628
                      OPT_GRAB,
3629
                      OPT_GRAB);
3630
    printf("\n");
3631
    av_opt_show(avcodec_opts[0], NULL);
3632
    printf("\n");
3633
    av_opt_show(avformat_opts, NULL);
3634
    printf("\n");
3635
    av_opt_show(sws_opts, NULL);
3636
}
3637

    
3638
static void opt_target(const char *arg)
3639
{
3640
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3641
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3642

    
3643
    if(!strncmp(arg, "pal-", 4)) {
3644
        norm = PAL;
3645
        arg += 4;
3646
    } else if(!strncmp(arg, "ntsc-", 5)) {
3647
        norm = NTSC;
3648
        arg += 5;
3649
    } else if(!strncmp(arg, "film-", 5)) {
3650
        norm = FILM;
3651
        arg += 5;
3652
    } else {
3653
        int fr;
3654
        /* Calculate FR via float to avoid int overflow */
3655
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3656
        if(fr == 25000) {
3657
            norm = PAL;
3658
        } else if((fr == 29970) || (fr == 23976)) {
3659
            norm = NTSC;
3660
        } else {
3661
            /* Try to determine PAL/NTSC by peeking in the input files */
3662
            if(nb_input_files) {
3663
                int i, j;
3664
                for(j = 0; j < nb_input_files; j++) {
3665
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3666
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3667
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3668
                            continue;
3669
                        fr = c->time_base.den * 1000 / c->time_base.num;
3670
                        if(fr == 25000) {
3671
                            norm = PAL;
3672
                            break;
3673
                        } else if((fr == 29970) || (fr == 23976)) {
3674
                            norm = NTSC;
3675
                            break;
3676
                        }
3677
                    }
3678
                    if(norm != UNKNOWN)
3679
                        break;
3680
                }
3681
            }
3682
        }
3683
        if(verbose && norm != UNKNOWN)
3684
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3685
    }
3686

    
3687
    if(norm == UNKNOWN) {
3688
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3689
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3690
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3691
        av_exit(1);
3692
    }
3693

    
3694
    if(!strcmp(arg, "vcd")) {
3695

    
3696
        opt_video_codec("mpeg1video");
3697
        opt_audio_codec("mp2");
3698
        opt_format("vcd");
3699

    
3700
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3701
        opt_frame_rate(NULL, frame_rates[norm]);
3702
        opt_default("g", norm == PAL ? "15" : "18");
3703

    
3704
        opt_default("b", "1150000");
3705
        opt_default("maxrate", "1150000");
3706
        opt_default("minrate", "1150000");
3707
        opt_default("bufsize", "327680"); // 40*1024*8;
3708

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

    
3713
        opt_default("packetsize", "2324");
3714
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3715

    
3716
        /* We have to offset the PTS, so that it is consistent with the SCR.
3717
           SCR starts at 36000, but the first two packs contain only padding
3718
           and the first pack from the other stream, respectively, may also have
3719
           been written before.
3720
           So the real data starts at SCR 36000+3*1200. */
3721
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3722
    } else if(!strcmp(arg, "svcd")) {
3723

    
3724
        opt_video_codec("mpeg2video");
3725
        opt_audio_codec("mp2");
3726
        opt_format("svcd");
3727

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

    
3732
        opt_default("b", "2040000");
3733
        opt_default("maxrate", "2516000");
3734
        opt_default("minrate", "0"); //1145000;
3735
        opt_default("bufsize", "1835008"); //224*1024*8;
3736
        opt_default("flags", "+scan_offset");
3737

    
3738

    
3739
        opt_default("ab", "224000");
3740
        audio_sample_rate = 44100;
3741

    
3742
        opt_default("packetsize", "2324");
3743

    
3744
    } else if(!strcmp(arg, "dvd")) {
3745

    
3746
        opt_video_codec("mpeg2video");
3747
        opt_audio_codec("ac3");
3748
        opt_format("dvd");
3749

    
3750
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3751
        opt_frame_rate(NULL, frame_rates[norm]);
3752
        opt_default("g", norm == PAL ? "15" : "18");
3753

    
3754
        opt_default("b", "6000000");
3755
        opt_default("maxrate", "9000000");
3756
        opt_default("minrate", "0"); //1500000;
3757
        opt_default("bufsize", "1835008"); //224*1024*8;
3758

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

    
3762
        opt_default("ab", "448000");
3763
        audio_sample_rate = 48000;
3764

    
3765
    } else if(!strncmp(arg, "dv", 2)) {
3766

    
3767
        opt_format("dv");
3768

    
3769
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3770
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3771
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3772
        opt_frame_rate(NULL, frame_rates[norm]);
3773

    
3774
        audio_sample_rate = 48000;
3775
        audio_channels = 2;
3776

    
3777
    } else {
3778
        fprintf(stderr, "Unknown target: %s\n", arg);
3779
        av_exit(1);
3780
    }
3781
}
3782

    
3783
static void opt_vstats_file (const char *arg)
3784
{
3785
    av_free (vstats_filename);
3786
    vstats_filename=av_strdup (arg);
3787
}
3788

    
3789
static void opt_vstats (void)
3790
{
3791
    char filename[40];
3792
    time_t today2 = time(NULL);
3793
    struct tm *today = localtime(&today2);
3794

    
3795
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3796
             today->tm_sec);
3797
    opt_vstats_file(filename);
3798
}
3799

    
3800
static int opt_bsf(const char *opt, const char *arg)
3801
{
3802
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3803
    AVBitStreamFilterContext **bsfp;
3804

    
3805
    if(!bsfc){
3806
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3807
        av_exit(1);
3808
    }
3809

    
3810
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3811
          *opt == 'a' ? &audio_bitstream_filters :
3812
                        &subtitle_bitstream_filters;
3813
    while(*bsfp)
3814
        bsfp= &(*bsfp)->next;
3815

    
3816
    *bsfp= bsfc;
3817

    
3818
    return 0;
3819
}
3820

    
3821
static int opt_preset(const char *opt, const char *arg)
3822
{
3823
    FILE *f=NULL;
3824
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3825
    int i;
3826
    const char *base[2]= { getenv("HOME"),
3827
                           FFMPEG_DATADIR,
3828
                         };
3829

    
3830
    if (*opt != 'f') {
3831
        for(i=!base[0]; i<2 && !f; i++){
3832
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3833
            f= fopen(filename, "r");
3834
            if(!f){
3835
                char *codec_name= *opt == 'v' ? video_codec_name :
3836
                                  *opt == 'a' ? audio_codec_name :
3837
                                                subtitle_codec_name;
3838
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3839
                f= fopen(filename, "r");
3840
            }
3841
        }
3842
    } else {
3843
        av_strlcpy(filename, arg, sizeof(filename));
3844
        f= fopen(filename, "r");
3845
    }
3846

    
3847
    if(!f){
3848
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3849
        av_exit(1);
3850
    }
3851

    
3852
    while(!feof(f)){
3853
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3854
        if(line[0] == '#' && !e)
3855
            continue;
3856
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3857
        if(e){
3858
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3859
            av_exit(1);
3860
        }
3861
        if(!strcmp(tmp, "acodec")){
3862
            opt_audio_codec(tmp2);
3863
        }else if(!strcmp(tmp, "vcodec")){
3864
            opt_video_codec(tmp2);
3865
        }else if(!strcmp(tmp, "scodec")){
3866
            opt_subtitle_codec(tmp2);
3867
        }else if(opt_default(tmp, tmp2) < 0){
3868
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3869
            av_exit(1);
3870
        }
3871
    }
3872

    
3873
    fclose(f);
3874

    
3875
    return 0;
3876
}
3877

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

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

    
3961
    /* audio options */
3962
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3963
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3964
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3965
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3966
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3967
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3968
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3969
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3970
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3971
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3972
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3973
    { "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" },
3974

    
3975
    /* subtitle options */
3976
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3977
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3978
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3979
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3980
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3981

    
3982
    /* grab options */
3983
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3984
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3985
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3986

    
3987
    /* muxer options */
3988
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3989
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3990

    
3991
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3992
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3993
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3994

    
3995
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3996
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3997
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3998
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3999

    
4000
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4001
    { NULL, },
4002
};
4003

    
4004
int main(int argc, char **argv)
4005
{
4006
    int i;
4007
    int64_t ti;
4008

    
4009
    avcodec_register_all();
4010
    avdevice_register_all();
4011
    av_register_all();
4012

    
4013
#if HAVE_ISATTY
4014
    if(isatty(STDIN_FILENO))
4015
        url_set_interrupt_cb(decode_interrupt_cb);
4016
#endif
4017

    
4018
    for(i=0; i<CODEC_TYPE_NB; i++){
4019
        avcodec_opts[i]= avcodec_alloc_context2(i);
4020
    }
4021
    avformat_opts = avformat_alloc_context();
4022
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4023

    
4024
    show_banner();
4025

    
4026
    /* parse options */
4027
    parse_options(argc, argv, options, opt_output_file);
4028

    
4029
    if(nb_output_files <= 0 && nb_input_files == 0) {
4030
        show_usage();
4031
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4032
        av_exit(1);
4033
    }
4034

    
4035
    /* file converter / grab */
4036
    if (nb_output_files <= 0) {
4037
        fprintf(stderr, "At least one output file must be specified\n");
4038
        av_exit(1);
4039
    }
4040

    
4041
    if (nb_input_files == 0) {
4042
        fprintf(stderr, "At least one input file must be specified\n");
4043
        av_exit(1);
4044
    }
4045

    
4046
    ti = getutime();
4047
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4048
                  stream_maps, nb_stream_maps) < 0)
4049
        av_exit(1);
4050
    ti = getutime() - ti;
4051
    if (do_benchmark) {
4052
        int maxrss = getmaxrss() / 1024;
4053
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4054
    }
4055

    
4056
    return av_exit(0);
4057
}