Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 6580d5e3

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
#include <time.h>
70

    
71
#include "cmdutils.h"
72

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

    
76
const char program_name[] = "FFmpeg";
77
const int program_birth_year = 2000;
78

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

    
87
/** select an input file for an output file */
88
typedef struct AVMetaDataMap {
89
    int out_file;
90
    int in_file;
91
} AVMetaDataMap;
92

    
93
static const OptionDef options[];
94

    
95
#define MAX_FILES 100
96

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

    
105
static AVFormatContext *output_files[MAX_FILES];
106
static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
107
static int nb_output_files = 0;
108
static int nb_ocodecs;
109

    
110
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
111
static int nb_stream_maps;
112

    
113
static AVMetaDataMap meta_data_maps[MAX_FILES];
114
static int nb_meta_data_maps;
115

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

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

    
161
static int subtitle_disable = 0;
162
static char *subtitle_codec_name = NULL;
163
static char *subtitle_language = NULL;
164
static int subtitle_codec_tag = 0;
165

    
166
static float mux_preload= 0.5;
167
static float mux_max_delay= 0.7;
168

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

    
196
static int rate_emu = 0;
197

    
198
static int  video_channel = 0;
199
static char *video_standard;
200

    
201
static int audio_volume = 256;
202

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

    
217
static int pgmyuv_compatibility_hack=0;
218
static float dts_delta_threshold = 10;
219

    
220
static unsigned int sws_flags = SWS_BICUBIC;
221

    
222
static int64_t timer_start;
223

    
224
static uint8_t *audio_buf;
225
static uint8_t *audio_out;
226
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
227

    
228
static short *samples;
229

    
230
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
231
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
232
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
233
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
234

    
235
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
236

    
237
struct AVInputStream;
238

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

    
259
    /* full frame size of first frame */
260
    int original_height;
261
    int original_width;
262

    
263
    /* cropping area sizes */
264
    int video_crop;
265
    int topBand;
266
    int bottomBand;
267
    int leftBand;
268
    int rightBand;
269

    
270
    /* cropping area of first frame */
271
    int original_topBand;
272
    int original_bottomBand;
273
    int original_leftBand;
274
    int original_rightBand;
275

    
276
    /* padding area sizes */
277
    int video_pad;
278
    int padtop;
279
    int padbottom;
280
    int padleft;
281
    int padright;
282

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

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

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

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

    
316
#if HAVE_TERMIOS_H
317

    
318
/* init terminal so that we can grab keys */
319
static struct termios oldtty;
320
#endif
321

    
322
static void term_exit(void)
323
{
324
#if HAVE_TERMIOS_H
325
    tcsetattr (0, TCSANOW, &oldtty);
326
#endif
327
}
328

    
329
static volatile int received_sigterm = 0;
330

    
331
static void
332
sigterm_handler(int sig)
333
{
334
    received_sigterm = sig;
335
    term_exit();
336
}
337

    
338
static void term_init(void)
339
{
340
#if HAVE_TERMIOS_H
341
    struct termios tty;
342

    
343
    tcgetattr (0, &tty);
344
    oldtty = tty;
345

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

    
355
    tcsetattr (0, TCSANOW, &tty);
356
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
357
#endif
358

    
359
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
360
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
361
#ifdef SIGXCPU
362
    signal(SIGXCPU, sigterm_handler);
363
#endif
364

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

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

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

    
395
        return n;
396
    }
397
#elif HAVE_CONIO_H
398
    if(kbhit())
399
        return(getch());
400
#endif
401
    return -1;
402
}
403

    
404
static int decode_interrupt_cb(void)
405
{
406
    return q_pressed || (q_pressed = read_key() == 'q');
407
}
408

    
409
static int av_exit(int ret)
410
{
411
    int i;
412

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

    
437
    av_free(intra_matrix);
438
    av_free(inter_matrix);
439

    
440
    if (vstats_file)
441
        fclose(vstats_file);
442
    av_free(vstats_filename);
443

    
444
    av_free(opt_names);
445

    
446
    av_free(video_codec_name);
447
    av_free(audio_codec_name);
448
    av_free(subtitle_codec_name);
449

    
450
    av_free(video_standard);
451

    
452
#if CONFIG_POWERPC_PERF
453
    void powerpc_display_perf_report(void);
454
    powerpc_display_perf_report();
455
#endif /* CONFIG_POWERPC_PERF */
456

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

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

    
473
    exit(ret); /* not all OS-es handle main() return value */
474
    return ret;
475
}
476

    
477
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
478
{
479
    int i, err;
480
    AVFormatContext *ic;
481
    int nopts = 0;
482

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

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

    
502
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
503
            st->stream_copy = 1;
504
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
505
            st->stream_copy = 1;
506

    
507
        if(!st->codec->thread_count)
508
            st->codec->thread_count = 1;
509
        if(st->codec->thread_count>1)
510
            avcodec_thread_init(st->codec, st->codec->thread_count);
511

    
512
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
513
            nopts = 1;
514
    }
515

    
516
    if (!nopts)
517
        s->timestamp = av_gettime();
518

    
519
    av_close_input_file(ic);
520
    return 0;
521
}
522

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

    
530
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
531
    int ret;
532

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

    
552
        bsfc= bsfc->next;
553
    }
554

    
555
    ret= av_interleaved_write_frame(s, pkt);
556
    if(ret < 0){
557
        print_error("av_interleaved_write_frame()", ret);
558
        av_exit(1);
559
    }
560
}
561

    
562
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
563

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

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

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

    
586
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
587
    if(coded_bps > 8*osize)
588
        audio_out_size= audio_out_size * coded_bps / (8*osize);
589
    audio_out_size += FF_MIN_BUFFER_SIZE;
590

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

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

    
603
    if (enc->channels != dec->channels)
604
        ost->audio_resample = 1;
605

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

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

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

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

    
659
                    if(byte_delta > allocated_for_size - size){
660
                        allocated_for_size= byte_delta + (int64_t)size;
661
                        goto need_realloc;
662
                    }
663
                    ist->is_start=0;
664

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

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

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

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

    
721
        frame_bytes = enc->frame_size * osize * enc->channels;
722

    
723
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
724
            AVPacket pkt;
725
            av_init_packet(&pkt);
726

    
727
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
728

    
729
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
730

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

    
746
            ost->sync_opts += enc->frame_size;
747
        }
748
    } else {
749
        AVPacket pkt;
750
        av_init_packet(&pkt);
751

    
752
        ost->sync_opts += size_out / (osize * enc->channels);
753

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

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

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

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

    
790
    dec = ist->st->codec;
791

    
792
    /* deinterlace : must be done before any resize */
793
    if (do_deinterlace) {
794
        int size;
795

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

    
802
        picture2 = &picture_tmp;
803
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
804

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

    
817
    if (picture != picture2)
818
        *picture = *picture2;
819
    *bufp = buf;
820
}
821

    
822
/* we begin to correct av delay at this threshold */
823
#define AV_DELAY_MAX 0.100
824

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

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

    
844
    enc = ost->st->codec;
845

    
846
    if (!subtitle_out) {
847
        subtitle_out = av_malloc(subtitle_out_max_size);
848
    }
849

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

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

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

    
888
static int bit_buffer_size= 1024*256;
889
static uint8_t *bit_buffer= NULL;
890

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

    
903
    avcodec_get_frame_defaults(&picture_crop_temp);
904
    avcodec_get_frame_defaults(&picture_pad_temp);
905

    
906
    enc = ost->st->codec;
907
    dec = ist->st->codec;
908

    
909
    /* by default, we output a single frame */
910
    nb_frames = 1;
911

    
912
    *frame_size = 0;
913

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

    
940
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
941
    if (nb_frames <= 0)
942
        return;
943

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

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

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

    
976
        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));
977
        if(!ost->video_resample)
978
            av_exit(1);
979
    }
980

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

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

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

    
1000
            ost->topBand    = topBand;
1001
            ost->bottomBand = bottomBand;
1002
            ost->leftBand   = leftBand;
1003
            ost->rightBand  = rightBand;
1004

    
1005
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
1006
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
1007
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1008

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

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

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

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

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

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

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

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

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

    
1115
static double psnr(double d){
1116
    return -10.0*log(d)/log(10.0);
1117
}
1118

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

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

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

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

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

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

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

    
1183

    
1184
    oc = output_files[0];
1185

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

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

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

    
1250
    if (verbose || is_last_report) {
1251
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1252

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

    
1257
        if (nb_frames_dup || nb_frames_drop)
1258
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1259
                  nb_frames_dup, nb_frames_drop);
1260

    
1261
        if (verbose >= 0)
1262
            fprintf(stderr, "%s    \r", buf);
1263

    
1264
        fflush(stderr);
1265
    }
1266

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

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

    
1296
    if(ist->next_pts == AV_NOPTS_VALUE)
1297
        ist->next_pts= ist->pts;
1298

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

    
1309
    if(pkt->dts != AV_NOPTS_VALUE)
1310
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1311

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

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

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

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

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

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

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

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

    
1448
                ost = ost_table[i];
1449
                if (ost->source_index == ist_index) {
1450
                    os = output_files[ost->file_index];
1451

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

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

    
1478
                        av_init_packet(&opkt);
1479

    
1480
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1481
                            continue;
1482

    
1483
                        /* no reencoding needed : output the packet directly */
1484
                        /* force the input stream PTS */
1485

    
1486
                        avcodec_get_frame_defaults(&avframe);
1487
                        ost->st->codec->coded_frame= &avframe;
1488
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1489

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

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

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

    
1509
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1510
                        opkt.flags= pkt->flags;
1511

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

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

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

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

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

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

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

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

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

    
1632
    return 0;
1633
 fail_decode:
1634
    return -1;
1635
}
1636

    
1637
static void print_sdp(AVFormatContext **avc, int n)
1638
{
1639
    char sdp[2048];
1640

    
1641
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1642
    printf("SDP:\n%s\n", sdp);
1643
    fflush(stdout);
1644
}
1645

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

    
1667
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1668
    if (!file_table)
1669
        goto fail;
1670

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

    
1681
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1682
    if (!ist_table)
1683
        goto fail;
1684

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

    
1702
            if (rate_emu) {
1703
                ist->start = av_gettime();
1704
            }
1705
        }
1706
    }
1707

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

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

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

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

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

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

    
1776
            } else {
1777
                int best_nb_frames=-1;
1778
                    /* get corresponding input stream index : we select the first one with the right type */
1779
                    found = 0;
1780
                    for(j=0;j<nb_istreams;j++) {
1781
                        int skip=0;
1782
                        ist = ist_table[j];
1783
                        if(opt_programid){
1784
                            int pi,si;
1785
                            AVFormatContext *f= input_files[ ist->file_index ];
1786
                            skip=1;
1787
                            for(pi=0; pi<f->nb_programs; pi++){
1788
                                AVProgram *p= f->programs[pi];
1789
                                if(p->id == opt_programid)
1790
                                    for(si=0; si<p->nb_stream_indexes; si++){
1791
                                        if(f->streams[ p->stream_index[si] ] == ist->st)
1792
                                            skip=0;
1793
                                    }
1794
                            }
1795
                        }
1796
                        if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
1797
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1798
                            if(best_nb_frames < ist->st->codec_info_nb_frames){
1799
                                best_nb_frames= ist->st->codec_info_nb_frames;
1800
                                ost->source_index = j;
1801
                                found = 1;
1802
                            }
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 *t = NULL, *lang = NULL;
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 (av_metadata_get(ist->st->metadata, "language", NULL, 0))
1846
            lang = av_metadata_get(ost->st->metadata, "language", NULL, 0);
1847
        while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
1848
            if (lang && !strcmp(t->key, "language"))
1849
                continue;
1850
            av_metadata_set2(&ost->st->metadata, t->key, t->value, 0);
1851
        }
1852

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

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

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

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

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

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

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

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

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

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

    
2092
    /* init pts */
2093
    for(i=0;i<nb_istreams;i++) {
2094
        AVStream *st;
2095
        ist = ist_table[i];
2096
        st= ist->st;
2097
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2098
        ist->next_pts = AV_NOPTS_VALUE;
2099
        ist->is_start = 1;
2100
    }
2101

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

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

    
2123
        out_file = output_files[out_file_index];
2124
        in_file = input_files[in_file_index];
2125

    
2126

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

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

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

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

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

    
2177
    if (want_sdp) {
2178
        print_sdp(output_files, nb_output_files);
2179
    }
2180

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

    
2187
    timer_start = av_gettime();
2188

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

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

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

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

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

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

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

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

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

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

    
2308
        /* finish if recording time exhausted */
2309
        if (recording_time != INT64_MAX &&
2310
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2311
            ist->is_past_recording_time = 1;
2312
            goto discard_packet;
2313
        }
2314

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

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

    
2327
    discard_packet:
2328
        av_free_packet(&pkt);
2329

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

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

    
2342
    term_exit();
2343

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

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

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

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

    
2370
    /* finished ! */
2371
    ret = 0;
2372

    
2373
 fail:
2374
    av_freep(&bit_buffer);
2375
    av_free(file_table);
2376

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

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

    
2419
    last_asked_format = arg;
2420
}
2421

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

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

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

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

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

    
2452
    opt_default(opt, arg);
2453

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

    
2457
    return 0;
2458
}
2459

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

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

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

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

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

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

    
2530
    r = (rgb >> 16);
2531
    g = ((rgb >> 8) & 255);
2532
    b = (rgb & 255);
2533

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

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

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

    
2557

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

    
2567

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

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

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

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

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

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

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

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

    
2630
    return 0;
2631
}
2632

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2748
    m = &stream_maps[nb_stream_maps++];
2749

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

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

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

    
2772
    m = &meta_data_maps[nb_meta_data_maps++];
2773

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

    
2778
    m->in_file = strtol(p, &p, 0);
2779
}
2780

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

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

    
2792
    if(stream >= MAX_STREAMS)
2793
        av_exit(1);
2794

    
2795
    input_files_ts_scale[nb_input_files][stream]= scale;
2796
}
2797

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

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

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

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

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

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

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

    
2851
    if (last_asked_format) {
2852
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
2853
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2854
            av_exit(1);
2855
        }
2856
        last_asked_format = NULL;
2857
    }
2858

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

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

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

    
2872
    memset(ap, 0, sizeof(*ap));
2873
    ap->prealloced_context = 1;
2874
    ap->sample_rate = audio_sample_rate;
2875
    ap->channels = audio_channels;
2876
    ap->time_base.den = frame_rate.num;
2877
    ap->time_base.num = frame_rate.den;
2878
    ap->width = frame_width + frame_padleft + frame_padright;
2879
    ap->height = frame_height + frame_padtop + frame_padbottom;
2880
    ap->pix_fmt = frame_pix_fmt;
2881
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2882
    ap->channel = video_channel;
2883
    ap->standard = video_standard;
2884

    
2885
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2886

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

    
2892
    if(pgmyuv_compatibility_hack)
2893
        ic->video_codec_id= CODEC_ID_PGMYUV;
2894

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

    
2925
    ic->loop_input = loop_input;
2926

    
2927
    /* If not enough info to get the stream parameters, we decode the
2928
       first frames to get it. (used in mpeg case for example) */
2929
    ret = av_find_stream_info(ic);
2930
    if (ret < 0 && verbose >= 0) {
2931
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2932
        av_exit(1);
2933
    }
2934

    
2935
    timestamp = start_time;
2936
    /* add the stream start time */
2937
    if (ic->start_time != AV_NOPTS_VALUE)
2938
        timestamp += ic->start_time;
2939

    
2940
    /* if seeking requested, we execute it */
2941
    if (start_time != 0) {
2942
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2943
        if (ret < 0) {
2944
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2945
                    filename, (double)timestamp / AV_TIME_BASE);
2946
        }
2947
        /* reset seek info */
2948
        start_time = 0;
2949
    }
2950

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

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

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

    
2994
                    (float)rfps / rfps_base, rfps, rfps_base);
2995
            }
2996
            /* update the current frame rate to match the stream frame rate */
2997
            frame_rate.num = rfps;
2998
            frame_rate.den = rfps_base;
2999

    
3000
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3001
            if(video_disable)
3002
                st->discard= AVDISCARD_ALL;
3003
            else if(video_discard)
3004
                st->discard= video_discard;
3005
            break;
3006
        case CODEC_TYPE_DATA:
3007
            break;
3008
        case CODEC_TYPE_SUBTITLE:
3009
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3010
            if(subtitle_disable)
3011
                st->discard = AVDISCARD_ALL;
3012
            break;
3013
        case CODEC_TYPE_ATTACHMENT:
3014
        case CODEC_TYPE_UNKNOWN:
3015
            nb_icodecs++;
3016
            break;
3017
        default:
3018
            abort();
3019
        }
3020
    }
3021

    
3022
    input_files[nb_input_files] = ic;
3023
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3024
    /* dump the file content */
3025
    if (verbose >= 0)
3026
        dump_format(ic, nb_input_files, filename, 0);
3027

    
3028
    nb_input_files++;
3029

    
3030
    video_channel = 0;
3031

    
3032
    av_freep(&video_codec_name);
3033
    av_freep(&audio_codec_name);
3034
    av_freep(&subtitle_codec_name);
3035
}
3036

    
3037
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3038
                                         int *has_subtitle_ptr)
3039
{
3040
    int has_video, has_audio, has_subtitle, i, j;
3041
    AVFormatContext *ic;
3042

    
3043
    has_video = 0;
3044
    has_audio = 0;
3045
    has_subtitle = 0;
3046
    for(j=0;j<nb_input_files;j++) {
3047
        ic = input_files[j];
3048
        for(i=0;i<ic->nb_streams;i++) {
3049
            AVCodecContext *enc = ic->streams[i]->codec;
3050
            switch(enc->codec_type) {
3051
            case CODEC_TYPE_AUDIO:
3052
                has_audio = 1;
3053
                break;
3054
            case CODEC_TYPE_VIDEO:
3055
                has_video = 1;
3056
                break;
3057
            case CODEC_TYPE_SUBTITLE:
3058
                has_subtitle = 1;
3059
                break;
3060
            case CODEC_TYPE_DATA:
3061
            case CODEC_TYPE_ATTACHMENT:
3062
            case CODEC_TYPE_UNKNOWN:
3063
                break;
3064
            default:
3065
                abort();
3066
            }
3067
        }
3068
    }
3069
    *has_video_ptr = has_video;
3070
    *has_audio_ptr = has_audio;
3071
    *has_subtitle_ptr = has_subtitle;
3072
}
3073

    
3074
static void new_video_stream(AVFormatContext *oc)
3075
{
3076
    AVStream *st;
3077
    AVCodecContext *video_enc;
3078
    enum CodecID codec_id;
3079

    
3080
    st = av_new_stream(oc, oc->nb_streams);
3081
    if (!st) {
3082
        fprintf(stderr, "Could not alloc stream\n");
3083
        av_exit(1);
3084
    }
3085
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3086
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3087
    video_bitstream_filters= NULL;
3088

    
3089
    avcodec_thread_init(st->codec, thread_count);
3090

    
3091
    video_enc = st->codec;
3092

    
3093
    if(video_codec_tag)
3094
        video_enc->codec_tag= video_codec_tag;
3095

    
3096
    if(   (video_global_header&1)
3097
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3098
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3099
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3100
    }
3101
    if(video_global_header&2){
3102
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3103
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3104
    }
3105

    
3106
    if (video_stream_copy) {
3107
        st->stream_copy = 1;
3108
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3109
        video_enc->sample_aspect_ratio =
3110
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3111
    } else {
3112
        const char *p;
3113
        int i;
3114
        AVCodec *codec;
3115
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3116

    
3117
        if (video_codec_name) {
3118
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3119
            codec = avcodec_find_encoder_by_name(video_codec_name);
3120
            output_codecs[nb_ocodecs] = codec;
3121
        } else {
3122
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3123
            codec = avcodec_find_encoder(codec_id);
3124
        }
3125

    
3126
        video_enc->codec_id = codec_id;
3127

    
3128
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3129

    
3130
        if (codec && codec->supported_framerates && !force_fps)
3131
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3132
        video_enc->time_base.den = fps.num;
3133
        video_enc->time_base.num = fps.den;
3134

    
3135
        video_enc->width = frame_width + frame_padright + frame_padleft;
3136
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3137
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3138
        video_enc->pix_fmt = frame_pix_fmt;
3139
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3140

    
3141
        if(codec && codec->pix_fmts){
3142
            const enum PixelFormat *p= codec->pix_fmts;
3143
            for(; *p!=-1; p++){
3144
                if(*p == video_enc->pix_fmt)
3145
                    break;
3146
            }
3147
            if(*p == -1)
3148
                video_enc->pix_fmt = codec->pix_fmts[0];
3149
        }
3150

    
3151
        if (intra_only)
3152
            video_enc->gop_size = 0;
3153
        if (video_qscale || same_quality) {
3154
            video_enc->flags |= CODEC_FLAG_QSCALE;
3155
            video_enc->global_quality=
3156
                st->quality = FF_QP2LAMBDA * video_qscale;
3157
        }
3158

    
3159
        if(intra_matrix)
3160
            video_enc->intra_matrix = intra_matrix;
3161
        if(inter_matrix)
3162
            video_enc->inter_matrix = inter_matrix;
3163

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

    
3194
        if (do_psnr)
3195
            video_enc->flags|= CODEC_FLAG_PSNR;
3196

    
3197
        /* two pass mode */
3198
        if (do_pass) {
3199
            if (do_pass == 1) {
3200
                video_enc->flags |= CODEC_FLAG_PASS1;
3201
            } else {
3202
                video_enc->flags |= CODEC_FLAG_PASS2;
3203
            }
3204
        }
3205
    }
3206
    nb_ocodecs++;
3207
    if (video_language) {
3208
        av_metadata_set(&st->metadata, "language", video_language);
3209
        av_freep(&video_language);
3210
    }
3211

    
3212
    /* reset some key parameters */
3213
    video_disable = 0;
3214
    av_freep(&video_codec_name);
3215
    video_stream_copy = 0;
3216
    frame_pix_fmt = PIX_FMT_NONE;
3217
}
3218

    
3219
static void new_audio_stream(AVFormatContext *oc)
3220
{
3221
    AVStream *st;
3222
    AVCodecContext *audio_enc;
3223
    enum CodecID codec_id;
3224

    
3225
    st = av_new_stream(oc, oc->nb_streams);
3226
    if (!st) {
3227
        fprintf(stderr, "Could not alloc stream\n");
3228
        av_exit(1);
3229
    }
3230
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3231

    
3232
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3233
    audio_bitstream_filters= NULL;
3234

    
3235
    avcodec_thread_init(st->codec, thread_count);
3236

    
3237
    audio_enc = st->codec;
3238
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3239

    
3240
    if(audio_codec_tag)
3241
        audio_enc->codec_tag= audio_codec_tag;
3242

    
3243
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3244
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3245
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3246
    }
3247
    if (audio_stream_copy) {
3248
        st->stream_copy = 1;
3249
        audio_enc->channels = audio_channels;
3250
    } else {
3251
        AVCodec *codec;
3252

    
3253
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3254

    
3255
        if (audio_codec_name) {
3256
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3257
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3258
            output_codecs[nb_ocodecs] = codec;
3259
        } else {
3260
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3261
            codec = avcodec_find_encoder(codec_id);
3262
        }
3263
        audio_enc->codec_id = codec_id;
3264

    
3265
        if (audio_qscale > QSCALE_NONE) {
3266
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3267
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3268
        }
3269
        audio_enc->channels = audio_channels;
3270
        audio_enc->sample_fmt = audio_sample_fmt;
3271
        audio_enc->channel_layout = channel_layout;
3272
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3273
            audio_enc->channel_layout = 0;
3274

    
3275
        if(codec && codec->sample_fmts){
3276
            const enum SampleFormat *p= codec->sample_fmts;
3277
            for(; *p!=-1; p++){
3278
                if(*p == audio_enc->sample_fmt)
3279
                    break;
3280
            }
3281
            if(*p == -1)
3282
                audio_enc->sample_fmt = codec->sample_fmts[0];
3283
        }
3284
    }
3285
    nb_ocodecs++;
3286
    audio_enc->sample_rate = audio_sample_rate;
3287
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3288
    if (audio_language) {
3289
        av_metadata_set(&st->metadata, "language", audio_language);
3290
        av_freep(&audio_language);
3291
    }
3292

    
3293
    /* reset some key parameters */
3294
    audio_disable = 0;
3295
    av_freep(&audio_codec_name);
3296
    audio_stream_copy = 0;
3297
}
3298

    
3299
static void new_subtitle_stream(AVFormatContext *oc)
3300
{
3301
    AVStream *st;
3302
    AVCodecContext *subtitle_enc;
3303

    
3304
    st = av_new_stream(oc, oc->nb_streams);
3305
    if (!st) {
3306
        fprintf(stderr, "Could not alloc stream\n");
3307
        av_exit(1);
3308
    }
3309
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3310

    
3311
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3312
    subtitle_bitstream_filters= NULL;
3313

    
3314
    subtitle_enc = st->codec;
3315
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3316

    
3317
    if(subtitle_codec_tag)
3318
        subtitle_enc->codec_tag= subtitle_codec_tag;
3319

    
3320
    if (subtitle_stream_copy) {
3321
        st->stream_copy = 1;
3322
    } else {
3323
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3324
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3325
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3326
    }
3327
    nb_ocodecs++;
3328

    
3329
    if (subtitle_language) {
3330
        av_metadata_set(&st->metadata, "language", subtitle_language);
3331
        av_freep(&subtitle_language);
3332
    }
3333

    
3334
    subtitle_disable = 0;
3335
    av_freep(&subtitle_codec_name);
3336
    subtitle_stream_copy = 0;
3337
}
3338

    
3339
static void opt_new_audio_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_audio_stream(oc);
3348
}
3349

    
3350
static void opt_new_video_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_video_stream(oc);
3359
}
3360

    
3361
static void opt_new_subtitle_stream(void)
3362
{
3363
    AVFormatContext *oc;
3364
    if (nb_output_files <= 0) {
3365
        fprintf(stderr, "At least one output file must be specified\n");
3366
        av_exit(1);
3367
    }
3368
    oc = output_files[nb_output_files - 1];
3369
    new_subtitle_stream(oc);
3370
}
3371

    
3372
static void opt_output_file(const char *filename)
3373
{
3374
    AVFormatContext *oc;
3375
    int use_video, use_audio, use_subtitle;
3376
    int input_has_video, input_has_audio, input_has_subtitle;
3377
    AVFormatParameters params, *ap = &params;
3378
    AVOutputFormat *file_oformat;
3379

    
3380
    if (!strcmp(filename, "-"))
3381
        filename = "pipe:";
3382

    
3383
    oc = avformat_alloc_context();
3384
    if (!oc) {
3385
        print_error(filename, AVERROR(ENOMEM));
3386
        av_exit(1);
3387
    }
3388

    
3389
    if (last_asked_format) {
3390
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3391
        if (!file_oformat) {
3392
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3393
            av_exit(1);
3394
        }
3395
        last_asked_format = NULL;
3396
    } else {
3397
        file_oformat = av_guess_format(NULL, filename, NULL);
3398
        if (!file_oformat) {
3399
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3400
                    filename);
3401
            av_exit(1);
3402
        }
3403
    }
3404

    
3405
    oc->oformat = file_oformat;
3406
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3407

    
3408
    if (!strcmp(file_oformat->name, "ffm") &&
3409
        av_strstart(filename, "http:", NULL)) {
3410
        /* special case for files sent to ffserver: we get the stream
3411
           parameters from ffserver */
3412
        int err = read_ffserver_streams(oc, filename);
3413
        if (err < 0) {
3414
            print_error(filename, err);
3415
            av_exit(1);
3416
        }
3417
    } else {
3418
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3419
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3420
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3421

    
3422
        /* disable if no corresponding type found and at least one
3423
           input file */
3424
        if (nb_input_files > 0) {
3425
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3426
                                         &input_has_subtitle);
3427
            if (!input_has_video)
3428
                use_video = 0;
3429
            if (!input_has_audio)
3430
                use_audio = 0;
3431
            if (!input_has_subtitle)
3432
                use_subtitle = 0;
3433
        }
3434

    
3435
        /* manual disable */
3436
        if (audio_disable) {
3437
            use_audio = 0;
3438
        }
3439
        if (video_disable) {
3440
            use_video = 0;
3441
        }
3442
        if (subtitle_disable) {
3443
            use_subtitle = 0;
3444
        }
3445

    
3446
        if (use_video) {
3447
            new_video_stream(oc);
3448
        }
3449

    
3450
        if (use_audio) {
3451
            new_audio_stream(oc);
3452
        }
3453

    
3454
        if (use_subtitle) {
3455
            new_subtitle_stream(oc);
3456
        }
3457

    
3458
        oc->timestamp = rec_timestamp;
3459

    
3460
        for(; metadata_count>0; metadata_count--){
3461
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3462
                                           metadata[metadata_count-1].value);
3463
        }
3464
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3465
    }
3466

    
3467
    output_files[nb_output_files++] = oc;
3468

    
3469
    /* check filename in case of an image number is expected */
3470
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3471
        if (!av_filename_number_test(oc->filename)) {
3472
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3473
            av_exit(1);
3474
        }
3475
    }
3476

    
3477
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3478
        /* test if it already exists to avoid loosing precious files */
3479
        if (!file_overwrite &&
3480
            (strchr(filename, ':') == NULL ||
3481
             filename[1] == ':' ||
3482
             av_strstart(filename, "file:", NULL))) {
3483
            if (url_exist(filename)) {
3484
                if (!using_stdin) {
3485
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3486
                    fflush(stderr);
3487
                    if (!read_yesno()) {
3488
                        fprintf(stderr, "Not overwriting - exiting\n");
3489
                        av_exit(1);
3490
                    }
3491
                }
3492
                else {
3493
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3494
                    av_exit(1);
3495
                }
3496
            }
3497
        }
3498

    
3499
        /* open the file */
3500
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3501
            fprintf(stderr, "Could not open '%s'\n", filename);
3502
            av_exit(1);
3503
        }
3504
    }
3505

    
3506
    memset(ap, 0, sizeof(*ap));
3507
    if (av_set_parameters(oc, ap) < 0) {
3508
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3509
                oc->filename);
3510
        av_exit(1);
3511
    }
3512

    
3513
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3514
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3515
    oc->loop_output = loop_output;
3516
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3517

    
3518
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3519
}
3520

    
3521
/* same option as mencoder */
3522
static void opt_pass(const char *pass_str)
3523
{
3524
    int pass;
3525
    pass = atoi(pass_str);
3526
    if (pass != 1 && pass != 2) {
3527
        fprintf(stderr, "pass number can be only 1 or 2\n");
3528
        av_exit(1);
3529
    }
3530
    do_pass = pass;
3531
}
3532

    
3533
static int64_t getutime(void)
3534
{
3535
#if HAVE_GETRUSAGE
3536
    struct rusage rusage;
3537

    
3538
    getrusage(RUSAGE_SELF, &rusage);
3539
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3540
#elif HAVE_GETPROCESSTIMES
3541
    HANDLE proc;
3542
    FILETIME c, e, k, u;
3543
    proc = GetCurrentProcess();
3544
    GetProcessTimes(proc, &c, &e, &k, &u);
3545
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3546
#else
3547
    return av_gettime();
3548
#endif
3549
}
3550

    
3551
static int64_t getmaxrss(void)
3552
{
3553
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3554
    struct rusage rusage;
3555
    getrusage(RUSAGE_SELF, &rusage);
3556
    return (int64_t)rusage.ru_maxrss * 1024;
3557
#elif HAVE_GETPROCESSMEMORYINFO
3558
    HANDLE proc;
3559
    PROCESS_MEMORY_COUNTERS memcounters;
3560
    proc = GetCurrentProcess();
3561
    memcounters.cb = sizeof(memcounters);
3562
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3563
    return memcounters.PeakPagefileUsage;
3564
#else
3565
    return 0;
3566
#endif
3567
}
3568

    
3569
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3570
{
3571
    int i;
3572
    const char *p = str;
3573
    for(i = 0;; i++) {
3574
        dest[i] = atoi(p);
3575
        if(i == 63)
3576
            break;
3577
        p = strchr(p, ',');
3578
        if(!p) {
3579
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3580
            av_exit(1);
3581
        }
3582
        p++;
3583
    }
3584
}
3585

    
3586
static void opt_inter_matrix(const char *arg)
3587
{
3588
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3589
    parse_matrix_coeffs(inter_matrix, arg);
3590
}
3591

    
3592
static void opt_intra_matrix(const char *arg)
3593
{
3594
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3595
    parse_matrix_coeffs(intra_matrix, arg);
3596
}
3597

    
3598
/**
3599
 * Trivial log callback.
3600
 * Only suitable for show_help and similar since it lacks prefix handling.
3601
 */
3602
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3603
{
3604
    vfprintf(stdout, fmt, vl);
3605
}
3606

    
3607
static void show_usage(void)
3608
{
3609
    printf("Hyper fast Audio and Video encoder\n");
3610
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3611
    printf("\n");
3612
}
3613

    
3614
static void show_help(void)
3615
{
3616
    av_log_set_callback(log_callback_help);
3617
    show_usage();
3618
    show_help_options(options, "Main options:\n",
3619
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3620
    show_help_options(options, "\nAdvanced options:\n",
3621
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3622
                      OPT_EXPERT);
3623
    show_help_options(options, "\nVideo options:\n",
3624
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3625
                      OPT_VIDEO);
3626
    show_help_options(options, "\nAdvanced Video options:\n",
3627
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3628
                      OPT_VIDEO | OPT_EXPERT);
3629
    show_help_options(options, "\nAudio options:\n",
3630
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3631
                      OPT_AUDIO);
3632
    show_help_options(options, "\nAdvanced Audio options:\n",
3633
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3634
                      OPT_AUDIO | OPT_EXPERT);
3635
    show_help_options(options, "\nSubtitle options:\n",
3636
                      OPT_SUBTITLE | OPT_GRAB,
3637
                      OPT_SUBTITLE);
3638
    show_help_options(options, "\nAudio/Video grab options:\n",
3639
                      OPT_GRAB,
3640
                      OPT_GRAB);
3641
    printf("\n");
3642
    av_opt_show(avcodec_opts[0], NULL);
3643
    printf("\n");
3644
    av_opt_show(avformat_opts, NULL);
3645
    printf("\n");
3646
    av_opt_show(sws_opts, NULL);
3647
}
3648

    
3649
static void opt_target(const char *arg)
3650
{
3651
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3652
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3653

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

    
3698
    if(norm == UNKNOWN) {
3699
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3700
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3701
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3702
        av_exit(1);
3703
    }
3704

    
3705
    if(!strcmp(arg, "vcd")) {
3706

    
3707
        opt_video_codec("mpeg1video");
3708
        opt_audio_codec("mp2");
3709
        opt_format("vcd");
3710

    
3711
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3712
        opt_frame_rate(NULL, frame_rates[norm]);
3713
        opt_default("g", norm == PAL ? "15" : "18");
3714

    
3715
        opt_default("b", "1150000");
3716
        opt_default("maxrate", "1150000");
3717
        opt_default("minrate", "1150000");
3718
        opt_default("bufsize", "327680"); // 40*1024*8;
3719

    
3720
        opt_default("ab", "224000");
3721
        audio_sample_rate = 44100;
3722
        audio_channels = 2;
3723

    
3724
        opt_default("packetsize", "2324");
3725
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3726

    
3727
        /* We have to offset the PTS, so that it is consistent with the SCR.
3728
           SCR starts at 36000, but the first two packs contain only padding
3729
           and the first pack from the other stream, respectively, may also have
3730
           been written before.
3731
           So the real data starts at SCR 36000+3*1200. */
3732
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3733
    } else if(!strcmp(arg, "svcd")) {
3734

    
3735
        opt_video_codec("mpeg2video");
3736
        opt_audio_codec("mp2");
3737
        opt_format("svcd");
3738

    
3739
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3740
        opt_frame_rate(NULL, frame_rates[norm]);
3741
        opt_default("g", norm == PAL ? "15" : "18");
3742

    
3743
        opt_default("b", "2040000");
3744
        opt_default("maxrate", "2516000");
3745
        opt_default("minrate", "0"); //1145000;
3746
        opt_default("bufsize", "1835008"); //224*1024*8;
3747
        opt_default("flags", "+scan_offset");
3748

    
3749

    
3750
        opt_default("ab", "224000");
3751
        audio_sample_rate = 44100;
3752

    
3753
        opt_default("packetsize", "2324");
3754

    
3755
    } else if(!strcmp(arg, "dvd")) {
3756

    
3757
        opt_video_codec("mpeg2video");
3758
        opt_audio_codec("ac3");
3759
        opt_format("dvd");
3760

    
3761
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3762
        opt_frame_rate(NULL, frame_rates[norm]);
3763
        opt_default("g", norm == PAL ? "15" : "18");
3764

    
3765
        opt_default("b", "6000000");
3766
        opt_default("maxrate", "9000000");
3767
        opt_default("minrate", "0"); //1500000;
3768
        opt_default("bufsize", "1835008"); //224*1024*8;
3769

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

    
3773
        opt_default("ab", "448000");
3774
        audio_sample_rate = 48000;
3775

    
3776
    } else if(!strncmp(arg, "dv", 2)) {
3777

    
3778
        opt_format("dv");
3779

    
3780
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3781
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3782
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3783
        opt_frame_rate(NULL, frame_rates[norm]);
3784

    
3785
        audio_sample_rate = 48000;
3786
        audio_channels = 2;
3787

    
3788
    } else {
3789
        fprintf(stderr, "Unknown target: %s\n", arg);
3790
        av_exit(1);
3791
    }
3792
}
3793

    
3794
static void opt_vstats_file (const char *arg)
3795
{
3796
    av_free (vstats_filename);
3797
    vstats_filename=av_strdup (arg);
3798
}
3799

    
3800
static void opt_vstats (void)
3801
{
3802
    char filename[40];
3803
    time_t today2 = time(NULL);
3804
    struct tm *today = localtime(&today2);
3805

    
3806
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3807
             today->tm_sec);
3808
    opt_vstats_file(filename);
3809
}
3810

    
3811
static int opt_bsf(const char *opt, const char *arg)
3812
{
3813
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3814
    AVBitStreamFilterContext **bsfp;
3815

    
3816
    if(!bsfc){
3817
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3818
        av_exit(1);
3819
    }
3820

    
3821
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3822
          *opt == 'a' ? &audio_bitstream_filters :
3823
                        &subtitle_bitstream_filters;
3824
    while(*bsfp)
3825
        bsfp= &(*bsfp)->next;
3826

    
3827
    *bsfp= bsfc;
3828

    
3829
    return 0;
3830
}
3831

    
3832
static int opt_preset(const char *opt, const char *arg)
3833
{
3834
    FILE *f=NULL;
3835
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3836
    int i;
3837
    const char *base[2]= { getenv("HOME"),
3838
                           FFMPEG_DATADIR,
3839
                         };
3840

    
3841
    if (*opt != 'f') {
3842
        for(i=!base[0]; i<2 && !f; i++){
3843
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3844
            f= fopen(filename, "r");
3845
            if(!f){
3846
                char *codec_name= *opt == 'v' ? video_codec_name :
3847
                                  *opt == 'a' ? audio_codec_name :
3848
                                                subtitle_codec_name;
3849
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3850
                f= fopen(filename, "r");
3851
            }
3852
        }
3853
    } else {
3854
        av_strlcpy(filename, arg, sizeof(filename));
3855
        f= fopen(filename, "r");
3856
    }
3857

    
3858
    if(!f){
3859
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3860
        av_exit(1);
3861
    }
3862

    
3863
    while(!feof(f)){
3864
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3865
        if(line[0] == '#' && !e)
3866
            continue;
3867
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3868
        if(e){
3869
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3870
            av_exit(1);
3871
        }
3872
        if(!strcmp(tmp, "acodec")){
3873
            opt_audio_codec(tmp2);
3874
        }else if(!strcmp(tmp, "vcodec")){
3875
            opt_video_codec(tmp2);
3876
        }else if(!strcmp(tmp, "scodec")){
3877
            opt_subtitle_codec(tmp2);
3878
        }else if(opt_default(tmp, tmp2) < 0){
3879
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3880
            av_exit(1);
3881
        }
3882
    }
3883

    
3884
    fclose(f);
3885

    
3886
    return 0;
3887
}
3888

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

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

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

    
3986
    /* subtitle options */
3987
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3988
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3989
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3990
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3991
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3992

    
3993
    /* grab options */
3994
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3995
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3996
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3997

    
3998
    /* muxer options */
3999
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4000
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4001

    
4002
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4003
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4004
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4005

    
4006
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4007
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4008
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4009
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4010

    
4011
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4012
    { NULL, },
4013
};
4014

    
4015
int main(int argc, char **argv)
4016
{
4017
    int i;
4018
    int64_t ti;
4019

    
4020
    avcodec_register_all();
4021
    avdevice_register_all();
4022
    av_register_all();
4023

    
4024
#if HAVE_ISATTY
4025
    if(isatty(STDIN_FILENO))
4026
        url_set_interrupt_cb(decode_interrupt_cb);
4027
#endif
4028

    
4029
    for(i=0; i<CODEC_TYPE_NB; i++){
4030
        avcodec_opts[i]= avcodec_alloc_context2(i);
4031
    }
4032
    avformat_opts = avformat_alloc_context();
4033
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4034

    
4035
    show_banner();
4036

    
4037
    /* parse options */
4038
    parse_options(argc, argv, options, opt_output_file);
4039

    
4040
    if(nb_output_files <= 0 && nb_input_files == 0) {
4041
        show_usage();
4042
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4043
        av_exit(1);
4044
    }
4045

    
4046
    /* file converter / grab */
4047
    if (nb_output_files <= 0) {
4048
        fprintf(stderr, "At least one output file must be specified\n");
4049
        av_exit(1);
4050
    }
4051

    
4052
    if (nb_input_files == 0) {
4053
        fprintf(stderr, "At least one input file must be specified\n");
4054
        av_exit(1);
4055
    }
4056

    
4057
    ti = getutime();
4058
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4059
                  stream_maps, nb_stream_maps) < 0)
4060
        av_exit(1);
4061
    ti = getutime() - ti;
4062
    if (do_benchmark) {
4063
        int maxrss = getmaxrss() / 1024;
4064
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4065
    }
4066

    
4067
    return av_exit(0);
4068
}