Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ c957c854

History | View | Annotate | Download (139 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 "libavutil/fifo.h"
40
#include "libavutil/avstring.h"
41
#include "libavformat/os_support.h"
42

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

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

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

    
65
#include "cmdutils.h"
66

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

    
70
#undef exit
71

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

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

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

    
89
static const OptionDef options[];
90

    
91
#define MAX_FILES 20
92

    
93
static AVFormatContext *input_files[MAX_FILES];
94
static int64_t input_files_ts_offset[MAX_FILES];
95
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
96
static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
97
static int nb_input_files = 0;
98
static int nb_icodecs;
99

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

    
105
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
106
static int nb_stream_maps;
107

    
108
static AVMetaDataMap meta_data_maps[MAX_FILES];
109
static int nb_meta_data_maps;
110

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

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

    
162
static int subtitle_disable = 0;
163
static char *subtitle_codec_name = NULL;
164
static char *subtitle_language = NULL;
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 AVBitStreamFilterContext *video_bitstream_filters=NULL;
225
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
226
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
227
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
228

    
229
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
230

    
231
struct AVInputStream;
232

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

    
251
    int video_crop;
252
    int topBand;             /* cropping area sizes */
253
    int leftBand;
254

    
255
    int video_pad;
256
    int padtop;              /* padding area sizes */
257
    int padbottom;
258
    int padleft;
259
    int padright;
260

    
261
    /* audio only */
262
    int audio_resample;
263
    ReSampleContext *resample; /* for audio resampling */
264
    int reformat_pair;
265
    AVAudioConvert *reformat_ctx;
266
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
267
    FILE *logfile;
268
} AVOutputStream;
269

    
270
typedef struct AVInputStream {
271
    int file_index;
272
    int index;
273
    AVStream *st;
274
    int discard;             /* true if stream data should be discarded */
275
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
276
    int64_t sample_index;      /* current sample */
277

    
278
    int64_t       start;     /* time when read started */
279
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
280
                                is not defined */
281
    int64_t       pts;       /* current pts */
282
    int is_start;            /* is 1 at the start and after a discontinuity */
283
} AVInputStream;
284

    
285
typedef struct AVInputFile {
286
    int eof_reached;      /* true if eof reached */
287
    int ist_index;        /* index of first stream in ist_table */
288
    int buffer_size;      /* current total buffer size */
289
    int nb_streams;       /* nb streams we are aware of */
290
} AVInputFile;
291

    
292
#if HAVE_TERMIOS_H
293

    
294
/* init terminal so that we can grab keys */
295
static struct termios oldtty;
296
#endif
297

    
298
static void term_exit(void)
299
{
300
#if HAVE_TERMIOS_H
301
    tcsetattr (0, TCSANOW, &oldtty);
302
#endif
303
}
304

    
305
static volatile sig_atomic_t received_sigterm = 0;
306

    
307
static void
308
sigterm_handler(int sig)
309
{
310
    received_sigterm = sig;
311
    term_exit();
312
}
313

    
314
static void term_init(void)
315
{
316
#if HAVE_TERMIOS_H
317
    struct termios tty;
318

    
319
    tcgetattr (0, &tty);
320
    oldtty = tty;
321

    
322
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
323
                          |INLCR|IGNCR|ICRNL|IXON);
324
    tty.c_oflag |= OPOST;
325
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
326
    tty.c_cflag &= ~(CSIZE|PARENB);
327
    tty.c_cflag |= CS8;
328
    tty.c_cc[VMIN] = 1;
329
    tty.c_cc[VTIME] = 0;
330

    
331
    tcsetattr (0, TCSANOW, &tty);
332
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
333
#endif
334

    
335
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
336
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
337
    /*
338
    register a function to be called at normal program termination
339
    */
340
    atexit(term_exit);
341
#if CONFIG_BEOS_NETSERVER
342
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
343
#endif
344
}
345

    
346
/* read a key without blocking */
347
static int read_key(void)
348
{
349
#if HAVE_TERMIOS_H
350
    int n = 1;
351
    unsigned char ch;
352
#if !CONFIG_BEOS_NETSERVER
353
    struct timeval tv;
354
    fd_set rfds;
355

    
356
    FD_ZERO(&rfds);
357
    FD_SET(0, &rfds);
358
    tv.tv_sec = 0;
359
    tv.tv_usec = 0;
360
    n = select(1, &rfds, NULL, NULL, &tv);
361
#endif
362
    if (n > 0) {
363
        n = read(0, &ch, 1);
364
        if (n == 1)
365
            return ch;
366

    
367
        return n;
368
    }
369
#elif HAVE_CONIO_H
370
    if(kbhit())
371
        return(getch());
372
#endif
373
    return -1;
374
}
375

    
376
static int decode_interrupt_cb(void)
377
{
378
    return q_pressed || (q_pressed = read_key() == 'q');
379
}
380

    
381
static int av_exit(int ret)
382
{
383
    int i;
384

    
385
    /* close files */
386
    for(i=0;i<nb_output_files;i++) {
387
        /* maybe av_close_output_file ??? */
388
        AVFormatContext *s = output_files[i];
389
        int j;
390
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
391
            url_fclose(s->pb);
392
        for(j=0;j<s->nb_streams;j++) {
393
            av_metadata_free(&s->streams[j]->metadata);
394
            av_free(s->streams[j]->codec);
395
            av_free(s->streams[j]);
396
        }
397
        for(j=0;j<s->nb_programs;j++) {
398
            av_metadata_free(&s->programs[j]->metadata);
399
        }
400
        for(j=0;j<s->nb_chapters;j++) {
401
            av_metadata_free(&s->chapters[j]->metadata);
402
        }
403
        av_metadata_free(&s->metadata);
404
        av_free(s);
405
    }
406
    for(i=0;i<nb_input_files;i++)
407
        av_close_input_file(input_files[i]);
408

    
409
    av_free(intra_matrix);
410
    av_free(inter_matrix);
411

    
412
    if (vstats_file)
413
        fclose(vstats_file);
414
    av_free(vstats_filename);
415

    
416
    av_free(opt_names);
417

    
418
    av_free(video_codec_name);
419
    av_free(audio_codec_name);
420
    av_free(subtitle_codec_name);
421

    
422
    av_free(video_standard);
423

    
424
#if CONFIG_POWERPC_PERF
425
    void powerpc_display_perf_report(void);
426
    powerpc_display_perf_report();
427
#endif /* CONFIG_POWERPC_PERF */
428

    
429
    if (received_sigterm) {
430
        fprintf(stderr,
431
            "Received signal %d: terminating.\n",
432
            (int) received_sigterm);
433
        exit (255);
434
    }
435

    
436
    exit(ret); /* not all OS-es handle main() return value */
437
    return ret;
438
}
439

    
440
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
441
{
442
    int i, err;
443
    AVFormatContext *ic;
444
    int nopts = 0;
445

    
446
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
447
    if (err < 0)
448
        return err;
449
    /* copy stream format */
450
    s->nb_streams = ic->nb_streams;
451
    for(i=0;i<ic->nb_streams;i++) {
452
        AVStream *st;
453

    
454
        // FIXME: a more elegant solution is needed
455
        st = av_mallocz(sizeof(AVStream));
456
        memcpy(st, ic->streams[i], sizeof(AVStream));
457
        st->codec = avcodec_alloc_context();
458
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
459
        s->streams[i] = st;
460

    
461
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
462
            st->stream_copy = 1;
463
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
464
            st->stream_copy = 1;
465

    
466
        if(!st->codec->thread_count)
467
            st->codec->thread_count = 1;
468
        if(st->codec->thread_count>1)
469
            avcodec_thread_init(st->codec, st->codec->thread_count);
470

    
471
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
472
            nopts = 1;
473
    }
474

    
475
    if (!nopts)
476
        s->timestamp = av_gettime();
477

    
478
    av_close_input_file(ic);
479
    return 0;
480
}
481

    
482
static double
483
get_sync_ipts(const AVOutputStream *ost)
484
{
485
    const AVInputStream *ist = ost->sync_ist;
486
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
487
}
488

    
489
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
490
    int ret;
491

    
492
    while(bsfc){
493
        AVPacket new_pkt= *pkt;
494
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
495
                                          &new_pkt.data, &new_pkt.size,
496
                                          pkt->data, pkt->size,
497
                                          pkt->flags & PKT_FLAG_KEY);
498
        if(a>0){
499
            av_free_packet(pkt);
500
            new_pkt.destruct= av_destruct_packet;
501
        } else if(a<0){
502
            fprintf(stderr, "%s failed for stream %d, codec %s",
503
                    bsfc->filter->name, pkt->stream_index,
504
                    avctx->codec ? avctx->codec->name : "copy");
505
            print_error("", a);
506
            if (exit_on_error)
507
                av_exit(1);
508
        }
509
        *pkt= new_pkt;
510

    
511
        bsfc= bsfc->next;
512
    }
513

    
514
    ret= av_interleaved_write_frame(s, pkt);
515
    if(ret < 0){
516
        print_error("av_interleaved_write_frame()", ret);
517
        av_exit(1);
518
    }
519
}
520

    
521
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
522

    
523
static void do_audio_out(AVFormatContext *s,
524
                         AVOutputStream *ost,
525
                         AVInputStream *ist,
526
                         unsigned char *buf, int size)
527
{
528
    uint8_t *buftmp;
529
    static uint8_t *audio_buf = NULL;
530
    static uint8_t *audio_out = NULL;
531
    static uint8_t *audio_out2 = NULL;
532
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
533

    
534
    int size_out, frame_bytes, ret;
535
    AVCodecContext *enc= ost->st->codec;
536
    AVCodecContext *dec= ist->st->codec;
537
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
538
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
539

    
540
    /* SC: dynamic allocation of buffers */
541
    if (!audio_buf)
542
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
543
    if (!audio_out)
544
        audio_out = av_malloc(audio_out_size);
545
    if (!audio_buf || !audio_out)
546
        return;               /* Should signal an error ! */
547

    
548
    if (enc->channels != dec->channels)
549
        ost->audio_resample = 1;
550

    
551
    if (ost->audio_resample && !ost->resample) {
552
        if (dec->sample_fmt != SAMPLE_FMT_S16)
553
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
554
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
555
                                               enc->sample_rate, dec->sample_rate,
556
                                               enc->sample_fmt,  dec->sample_fmt,
557
                                               16, 10, 0, 0.8);
558
        if (!ost->resample) {
559
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
560
                    dec->channels, dec->sample_rate,
561
                    enc->channels, enc->sample_rate);
562
            av_exit(1);
563
        }
564
    }
565

    
566
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
567
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
568
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
569
        if (!audio_out2)
570
            audio_out2 = av_malloc(audio_out_size);
571
        if (!audio_out2)
572
            av_exit(1);
573
        if (ost->reformat_ctx)
574
            av_audio_convert_free(ost->reformat_ctx);
575
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
576
                                                   dec->sample_fmt, 1, NULL, 0);
577
        if (!ost->reformat_ctx) {
578
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
579
                avcodec_get_sample_fmt_name(dec->sample_fmt),
580
                avcodec_get_sample_fmt_name(enc->sample_fmt));
581
            av_exit(1);
582
        }
583
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
584
    }
585

    
586
    if(audio_sync_method){
587
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
588
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
589
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
590
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
591

    
592
        //FIXME resample delay
593
        if(fabs(delta) > 50){
594
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
595
                if(byte_delta < 0){
596
                    byte_delta= FFMAX(byte_delta, -size);
597
                    size += byte_delta;
598
                    buf  -= byte_delta;
599
                    if(verbose > 2)
600
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
601
                    if(!size)
602
                        return;
603
                    ist->is_start=0;
604
                }else{
605
                    static uint8_t *input_tmp= NULL;
606
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
607

    
608
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
609
                        ist->is_start=0;
610
                    else
611
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
612

    
613
                    memset(input_tmp, 0, byte_delta);
614
                    memcpy(input_tmp + byte_delta, buf, size);
615
                    buf= input_tmp;
616
                    size += byte_delta;
617
                    if(verbose > 2)
618
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
619
                }
620
            }else if(audio_sync_method>1){
621
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
622
                assert(ost->audio_resample);
623
                if(verbose > 2)
624
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
625
//                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));
626
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
627
            }
628
        }
629
    }else
630
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
631
                        - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
632

    
633
    if (ost->audio_resample) {
634
        buftmp = audio_buf;
635
        size_out = audio_resample(ost->resample,
636
                                  (short *)buftmp, (short *)buf,
637
                                  size / (ist->st->codec->channels * isize));
638
        size_out = size_out * enc->channels * osize;
639
    } else {
640
        buftmp = buf;
641
        size_out = size;
642
    }
643

    
644
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
645
        const void *ibuf[6]= {buftmp};
646
        void *obuf[6]= {audio_out2};
647
        int istride[6]= {isize};
648
        int ostride[6]= {osize};
649
        int len= size_out/istride[0];
650
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
651
            printf("av_audio_convert() failed\n");
652
            if (exit_on_error)
653
                av_exit(1);
654
            return;
655
        }
656
        buftmp = audio_out2;
657
        size_out = len*osize;
658
    }
659

    
660
    /* now encode as many frames as possible */
661
    if (enc->frame_size > 1) {
662
        /* output resampled raw samples */
663
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
664
            fprintf(stderr, "av_fifo_realloc2() failed\n");
665
            av_exit(1);
666
        }
667
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
668

    
669
        frame_bytes = enc->frame_size * osize * enc->channels;
670

    
671
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
672
            AVPacket pkt;
673
            av_init_packet(&pkt);
674

    
675
            av_fifo_generic_read(ost->fifo, frame_bytes, NULL, audio_buf);
676

    
677
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
678

    
679
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
680
                                       (short *)audio_buf);
681
            if (ret < 0) {
682
                fprintf(stderr, "Audio encoding failed\n");
683
                av_exit(1);
684
            }
685
            audio_size += ret;
686
            pkt.stream_index= ost->index;
687
            pkt.data= audio_out;
688
            pkt.size= ret;
689
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
690
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
691
            pkt.flags |= PKT_FLAG_KEY;
692
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
693

    
694
            ost->sync_opts += enc->frame_size;
695
        }
696
    } else {
697
        AVPacket pkt;
698
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
699
        av_init_packet(&pkt);
700

    
701
        ost->sync_opts += size_out / (osize * enc->channels);
702

    
703
        /* output a pcm frame */
704
        /* determine the size of the coded buffer */
705
        size_out /= osize;
706
        if (coded_bps)
707
            size_out *= coded_bps;
708

    
709
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
710
        ret = avcodec_encode_audio(enc, audio_out, size_out,
711
                                   (short *)buftmp);
712
        if (ret < 0) {
713
            fprintf(stderr, "Audio encoding failed\n");
714
            av_exit(1);
715
        }
716
        audio_size += ret;
717
        pkt.stream_index= ost->index;
718
        pkt.data= audio_out;
719
        pkt.size= ret;
720
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
721
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
722
        pkt.flags |= PKT_FLAG_KEY;
723
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
724
    }
725
}
726

    
727
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
728
{
729
    AVCodecContext *dec;
730
    AVPicture *picture2;
731
    AVPicture picture_tmp;
732
    uint8_t *buf = 0;
733

    
734
    dec = ist->st->codec;
735

    
736
    /* deinterlace : must be done before any resize */
737
    if (do_deinterlace) {
738
        int size;
739

    
740
        /* create temporary picture */
741
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
742
        buf = av_malloc(size);
743
        if (!buf)
744
            return;
745

    
746
        picture2 = &picture_tmp;
747
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
748

    
749
        if (do_deinterlace){
750
            if(avpicture_deinterlace(picture2, picture,
751
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
752
                /* if error, do not deinterlace */
753
                fprintf(stderr, "Deinterlacing failed\n");
754
                av_free(buf);
755
                buf = NULL;
756
                picture2 = picture;
757
            }
758
        } else {
759
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
760
        }
761
    } else {
762
        picture2 = picture;
763
    }
764

    
765
    if (picture != picture2)
766
        *picture = *picture2;
767
    *bufp = buf;
768
}
769

    
770
/* we begin to correct av delay at this threshold */
771
#define AV_DELAY_MAX 0.100
772

    
773
static void do_subtitle_out(AVFormatContext *s,
774
                            AVOutputStream *ost,
775
                            AVInputStream *ist,
776
                            AVSubtitle *sub,
777
                            int64_t pts)
778
{
779
    static uint8_t *subtitle_out = NULL;
780
    int subtitle_out_max_size = 65536;
781
    int subtitle_out_size, nb, i;
782
    AVCodecContext *enc;
783
    AVPacket pkt;
784

    
785
    if (pts == AV_NOPTS_VALUE) {
786
        fprintf(stderr, "Subtitle packets must have a pts\n");
787
        if (exit_on_error)
788
            av_exit(1);
789
        return;
790
    }
791

    
792
    enc = ost->st->codec;
793

    
794
    if (!subtitle_out) {
795
        subtitle_out = av_malloc(subtitle_out_max_size);
796
    }
797

    
798
    /* Note: DVB subtitle need one packet to draw them and one other
799
       packet to clear them */
800
    /* XXX: signal it in the codec context ? */
801
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
802
        nb = 2;
803
    else
804
        nb = 1;
805

    
806
    for(i = 0; i < nb; i++) {
807
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
808
                                                    subtitle_out_max_size, sub);
809

    
810
        av_init_packet(&pkt);
811
        pkt.stream_index = ost->index;
812
        pkt.data = subtitle_out;
813
        pkt.size = subtitle_out_size;
814
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
815
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
816
            /* XXX: the pts correction is handled here. Maybe handling
817
               it in the codec would be better */
818
            if (i == 0)
819
                pkt.pts += 90 * sub->start_display_time;
820
            else
821
                pkt.pts += 90 * sub->end_display_time;
822
        }
823
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
824
    }
825
}
826

    
827
static int bit_buffer_size= 1024*256;
828
static uint8_t *bit_buffer= NULL;
829

    
830
static void do_video_out(AVFormatContext *s,
831
                         AVOutputStream *ost,
832
                         AVInputStream *ist,
833
                         AVFrame *in_picture,
834
                         int *frame_size)
835
{
836
    int nb_frames, i, ret;
837
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
838
    AVFrame picture_crop_temp, picture_pad_temp;
839
    AVCodecContext *enc, *dec;
840

    
841
    avcodec_get_frame_defaults(&picture_crop_temp);
842
    avcodec_get_frame_defaults(&picture_pad_temp);
843

    
844
    enc = ost->st->codec;
845
    dec = ist->st->codec;
846

    
847
    /* by default, we output a single frame */
848
    nb_frames = 1;
849

    
850
    *frame_size = 0;
851

    
852
    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
853
        double vdelta;
854
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
855
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
856
        if (vdelta < -1.1)
857
            nb_frames = 0;
858
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
859
            if(vdelta<=-0.6){
860
                nb_frames=0;
861
            }else if(vdelta>0.6)
862
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
863
        }else if (vdelta > 1.1)
864
            nb_frames = lrintf(vdelta);
865
//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);
866
        if (nb_frames == 0){
867
            ++nb_frames_drop;
868
            if (verbose>2)
869
                fprintf(stderr, "*** drop!\n");
870
        }else if (nb_frames > 1) {
871
            nb_frames_dup += nb_frames;
872
            if (verbose>2)
873
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
874
        }
875
    }else
876
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
877

    
878
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
879
    if (nb_frames <= 0)
880
        return;
881

    
882
    if (ost->video_crop) {
883
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
884
            fprintf(stderr, "error cropping picture\n");
885
            if (exit_on_error)
886
                av_exit(1);
887
            return;
888
        }
889
        formatted_picture = &picture_crop_temp;
890
    } else {
891
        formatted_picture = in_picture;
892
    }
893

    
894
    final_picture = formatted_picture;
895
    padding_src = formatted_picture;
896
    resampling_dst = &ost->pict_tmp;
897
    if (ost->video_pad) {
898
        final_picture = &ost->pict_tmp;
899
        if (ost->video_resample) {
900
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
901
                fprintf(stderr, "error padding picture\n");
902
                if (exit_on_error)
903
                    av_exit(1);
904
                return;
905
            }
906
            resampling_dst = &picture_pad_temp;
907
        }
908
    }
909

    
910
    if (ost->video_resample) {
911
        padding_src = NULL;
912
        final_picture = &ost->pict_tmp;
913
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
914
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
915
    }
916

    
917
    if (ost->video_pad) {
918
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
919
                enc->height, enc->width, enc->pix_fmt,
920
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
921
    }
922

    
923
    /* duplicates frame if needed */
924
    for(i=0;i<nb_frames;i++) {
925
        AVPacket pkt;
926
        av_init_packet(&pkt);
927
        pkt.stream_index= ost->index;
928

    
929
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
930
            /* raw pictures are written as AVPicture structure to
931
               avoid any copies. We support temorarily the older
932
               method. */
933
            AVFrame* old_frame = enc->coded_frame;
934
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
935
            pkt.data= (uint8_t *)final_picture;
936
            pkt.size=  sizeof(AVPicture);
937
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
938
            pkt.flags |= PKT_FLAG_KEY;
939

    
940
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
941
            enc->coded_frame = old_frame;
942
        } else {
943
            AVFrame big_picture;
944

    
945
            big_picture= *final_picture;
946
            /* better than nothing: use input picture interlaced
947
               settings */
948
            big_picture.interlaced_frame = in_picture->interlaced_frame;
949
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
950
                if(top_field_first == -1)
951
                    big_picture.top_field_first = in_picture->top_field_first;
952
                else
953
                    big_picture.top_field_first = top_field_first;
954
            }
955

    
956
            /* handles sameq here. This is not correct because it may
957
               not be a global option */
958
            if (same_quality) {
959
                big_picture.quality = ist->st->quality;
960
            }else
961
                big_picture.quality = ost->st->quality;
962
            if(!me_threshold)
963
                big_picture.pict_type = 0;
964
//            big_picture.pts = AV_NOPTS_VALUE;
965
            big_picture.pts= ost->sync_opts;
966
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
967
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
968
            ret = avcodec_encode_video(enc,
969
                                       bit_buffer, bit_buffer_size,
970
                                       &big_picture);
971
            if (ret < 0) {
972
                fprintf(stderr, "Video encoding failed\n");
973
                av_exit(1);
974
            }
975
            //enc->frame_number = enc->real_pict_num;
976
            if(ret>0){
977
                pkt.data= bit_buffer;
978
                pkt.size= ret;
979
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
980
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
981
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
982
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
983
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
984

    
985
                if(enc->coded_frame->key_frame)
986
                    pkt.flags |= PKT_FLAG_KEY;
987
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
988
                *frame_size = ret;
989
                video_size += ret;
990
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
991
                //        enc->frame_number-1, enc->real_pict_num, ret,
992
                //        enc->pict_type);
993
                /* if two pass, output log */
994
                if (ost->logfile && enc->stats_out) {
995
                    fprintf(ost->logfile, "%s", enc->stats_out);
996
                }
997
            }
998
        }
999
        ost->sync_opts++;
1000
        ost->frame_number++;
1001
    }
1002
}
1003

    
1004
static double psnr(double d){
1005
    return -10.0*log(d)/log(10.0);
1006
}
1007

    
1008
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1009
                           int frame_size)
1010
{
1011
    AVCodecContext *enc;
1012
    int frame_number;
1013
    double ti1, bitrate, avg_bitrate;
1014

    
1015
    /* this is executed just the first time do_video_stats is called */
1016
    if (!vstats_file) {
1017
        vstats_file = fopen(vstats_filename, "w");
1018
        if (!vstats_file) {
1019
            perror("fopen");
1020
            av_exit(1);
1021
        }
1022
    }
1023

    
1024
    enc = ost->st->codec;
1025
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1026
        frame_number = ost->frame_number;
1027
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1028
        if (enc->flags&CODEC_FLAG_PSNR)
1029
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1030

    
1031
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1032
        /* compute pts value */
1033
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1034
        if (ti1 < 0.01)
1035
            ti1 = 0.01;
1036

    
1037
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1038
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1039
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1040
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1041
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1042
    }
1043
}
1044

    
1045
static void print_report(AVFormatContext **output_files,
1046
                         AVOutputStream **ost_table, int nb_ostreams,
1047
                         int is_last_report)
1048
{
1049
    char buf[1024];
1050
    AVOutputStream *ost;
1051
    AVFormatContext *oc, *os;
1052
    int64_t total_size;
1053
    AVCodecContext *enc;
1054
    int frame_number, vid, i;
1055
    double bitrate, ti1, pts;
1056
    static int64_t last_time = -1;
1057
    static int qp_histogram[52];
1058

    
1059
    if (!is_last_report) {
1060
        int64_t cur_time;
1061
        /* display the report every 0.5 seconds */
1062
        cur_time = av_gettime();
1063
        if (last_time == -1) {
1064
            last_time = cur_time;
1065
            return;
1066
        }
1067
        if ((cur_time - last_time) < 500000)
1068
            return;
1069
        last_time = cur_time;
1070
    }
1071

    
1072

    
1073
    oc = output_files[0];
1074

    
1075
    total_size = url_fsize(oc->pb);
1076
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1077
        total_size= url_ftell(oc->pb);
1078

    
1079
    buf[0] = '\0';
1080
    ti1 = 1e10;
1081
    vid = 0;
1082
    for(i=0;i<nb_ostreams;i++) {
1083
        ost = ost_table[i];
1084
        os = output_files[ost->file_index];
1085
        enc = ost->st->codec;
1086
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1087
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1088
                     !ost->st->stream_copy ?
1089
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1090
        }
1091
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1092
            float t = (av_gettime()-timer_start) / 1000000.0;
1093

    
1094
            frame_number = ost->frame_number;
1095
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1096
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1097
                     !ost->st->stream_copy ?
1098
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1099
            if(is_last_report)
1100
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1101
            if(qp_hist){
1102
                int j;
1103
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1104
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1105
                    qp_histogram[qp]++;
1106
                for(j=0; j<32; j++)
1107
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1108
            }
1109
            if (enc->flags&CODEC_FLAG_PSNR){
1110
                int j;
1111
                double error, error_sum=0;
1112
                double scale, scale_sum=0;
1113
                char type[3]= {'Y','U','V'};
1114
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1115
                for(j=0; j<3; j++){
1116
                    if(is_last_report){
1117
                        error= enc->error[j];
1118
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1119
                    }else{
1120
                        error= enc->coded_frame->error[j];
1121
                        scale= enc->width*enc->height*255.0*255.0;
1122
                    }
1123
                    if(j) scale/=4;
1124
                    error_sum += error;
1125
                    scale_sum += scale;
1126
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1127
                }
1128
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1129
            }
1130
            vid = 1;
1131
        }
1132
        /* compute min output value */
1133
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1134
        if ((pts < ti1) && (pts > 0))
1135
            ti1 = pts;
1136
    }
1137
    if (ti1 < 0.01)
1138
        ti1 = 0.01;
1139

    
1140
    if (verbose || is_last_report) {
1141
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1142

    
1143
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1144
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1145
            (double)total_size / 1024, ti1, bitrate);
1146

    
1147
        if (verbose > 1)
1148
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1149
                  nb_frames_dup, nb_frames_drop);
1150

    
1151
        if (verbose >= 0)
1152
            fprintf(stderr, "%s    \r", buf);
1153

    
1154
        fflush(stderr);
1155
    }
1156

    
1157
    if (is_last_report && verbose >= 0){
1158
        int64_t raw= audio_size + video_size + extra_size;
1159
        fprintf(stderr, "\n");
1160
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1161
                video_size/1024.0,
1162
                audio_size/1024.0,
1163
                extra_size/1024.0,
1164
                100.0*(total_size - raw)/raw
1165
        );
1166
    }
1167
}
1168

    
1169
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1170
static int output_packet(AVInputStream *ist, int ist_index,
1171
                         AVOutputStream **ost_table, int nb_ostreams,
1172
                         const AVPacket *pkt)
1173
{
1174
    AVFormatContext *os;
1175
    AVOutputStream *ost;
1176
    uint8_t *ptr;
1177
    int len, ret, i;
1178
    uint8_t *data_buf;
1179
    int data_size, got_picture;
1180
    AVFrame picture;
1181
    void *buffer_to_free;
1182
    static unsigned int samples_size= 0;
1183
    static short *samples= NULL;
1184
    AVSubtitle subtitle, *subtitle_to_free;
1185
    int got_subtitle;
1186

    
1187
    if(ist->next_pts == AV_NOPTS_VALUE)
1188
        ist->next_pts= ist->pts;
1189

    
1190
    if (pkt == NULL) {
1191
        /* EOF handling */
1192
        ptr = NULL;
1193
        len = 0;
1194
        goto handle_eof;
1195
    }
1196

    
1197
    if(pkt->dts != AV_NOPTS_VALUE)
1198
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1199

    
1200
    len = pkt->size;
1201
    ptr = pkt->data;
1202

    
1203
    //while we have more to decode or while the decoder did output something on EOF
1204
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1205
    handle_eof:
1206
        ist->pts= ist->next_pts;
1207

    
1208
        if(len && len != pkt->size && verbose>0)
1209
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1210

    
1211
        /* decode the packet if needed */
1212
        data_buf = NULL; /* fail safe */
1213
        data_size = 0;
1214
        subtitle_to_free = NULL;
1215
        if (ist->decoding_needed) {
1216
            switch(ist->st->codec->codec_type) {
1217
            case CODEC_TYPE_AUDIO:{
1218
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1219
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1220
                    av_free(samples);
1221
                    samples= av_malloc(samples_size);
1222
                }
1223
                data_size= samples_size;
1224
                    /* XXX: could avoid copy if PCM 16 bits with same
1225
                       endianness as CPU */
1226
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1227
                                           ptr, len);
1228
                if (ret < 0)
1229
                    goto fail_decode;
1230
                ptr += ret;
1231
                len -= ret;
1232
                /* Some bug in mpeg audio decoder gives */
1233
                /* data_size < 0, it seems they are overflows */
1234
                if (data_size <= 0) {
1235
                    /* no audio frame */
1236
                    continue;
1237
                }
1238
                data_buf = (uint8_t *)samples;
1239
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1240
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1241
                break;}
1242
            case CODEC_TYPE_VIDEO:
1243
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1244
                    /* XXX: allocate picture correctly */
1245
                    avcodec_get_frame_defaults(&picture);
1246

    
1247
                    ret = avcodec_decode_video(ist->st->codec,
1248
                                               &picture, &got_picture, ptr, len);
1249
                    ist->st->quality= picture.quality;
1250
                    if (ret < 0)
1251
                        goto fail_decode;
1252
                    if (!got_picture) {
1253
                        /* no picture yet */
1254
                        goto discard_packet;
1255
                    }
1256
                    if (ist->st->codec->time_base.num != 0) {
1257
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1258
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1259
                                          ist->st->codec->time_base.num * ticks) /
1260
                            ist->st->codec->time_base.den;
1261
                    }
1262
                    len = 0;
1263
                    break;
1264
            case CODEC_TYPE_SUBTITLE:
1265
                ret = avcodec_decode_subtitle(ist->st->codec,
1266
                                              &subtitle, &got_subtitle, ptr, len);
1267
                if (ret < 0)
1268
                    goto fail_decode;
1269
                if (!got_subtitle) {
1270
                    goto discard_packet;
1271
                }
1272
                subtitle_to_free = &subtitle;
1273
                len = 0;
1274
                break;
1275
            default:
1276
                goto fail_decode;
1277
            }
1278
        } else {
1279
            switch(ist->st->codec->codec_type) {
1280
            case CODEC_TYPE_AUDIO:
1281
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1282
                    ist->st->codec->sample_rate;
1283
                break;
1284
            case CODEC_TYPE_VIDEO:
1285
                if (ist->st->codec->time_base.num != 0) {
1286
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1287
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1288
                                      ist->st->codec->time_base.num * ticks) /
1289
                        ist->st->codec->time_base.den;
1290
                }
1291
                break;
1292
            }
1293
            data_buf = ptr;
1294
            data_size = len;
1295
            ret = len;
1296
            len = 0;
1297
        }
1298

    
1299
        buffer_to_free = NULL;
1300
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1301
            pre_process_video_frame(ist, (AVPicture *)&picture,
1302
                                    &buffer_to_free);
1303
        }
1304

    
1305
        // preprocess audio (volume)
1306
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1307
            if (audio_volume != 256) {
1308
                short *volp;
1309
                volp = samples;
1310
                for(i=0;i<(data_size / sizeof(short));i++) {
1311
                    int v = ((*volp) * audio_volume + 128) >> 8;
1312
                    if (v < -32768) v = -32768;
1313
                    if (v >  32767) v = 32767;
1314
                    *volp++ = v;
1315
                }
1316
            }
1317
        }
1318

    
1319
        /* frame rate emulation */
1320
        if (rate_emu) {
1321
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1322
            int64_t now = av_gettime() - ist->start;
1323
            if (pts > now)
1324
                usleep(pts - now);
1325
        }
1326

    
1327
        /* if output time reached then transcode raw format,
1328
           encode packets and output them */
1329
        if (start_time == 0 || ist->pts >= start_time)
1330
            for(i=0;i<nb_ostreams;i++) {
1331
                int frame_size;
1332

    
1333
                ost = ost_table[i];
1334
                if (ost->source_index == ist_index) {
1335
                    os = output_files[ost->file_index];
1336

    
1337
#if 0
1338
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1339
                           (double)pkt->pts / AV_TIME_BASE,
1340
                           ((double)ist->pts / AV_TIME_BASE) -
1341
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1342
#endif
1343
                    /* set the input output pts pairs */
1344
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1345

    
1346
                    if (ost->encoding_needed) {
1347
                        switch(ost->st->codec->codec_type) {
1348
                        case CODEC_TYPE_AUDIO:
1349
                            do_audio_out(os, ost, ist, data_buf, data_size);
1350
                            break;
1351
                        case CODEC_TYPE_VIDEO:
1352
                            do_video_out(os, ost, ist, &picture, &frame_size);
1353
                            if (vstats_filename && frame_size)
1354
                                do_video_stats(os, ost, frame_size);
1355
                            break;
1356
                        case CODEC_TYPE_SUBTITLE:
1357
                            do_subtitle_out(os, ost, ist, &subtitle,
1358
                                            pkt->pts);
1359
                            break;
1360
                        default:
1361
                            abort();
1362
                        }
1363
                    } else {
1364
                        AVFrame avframe; //FIXME/XXX remove this
1365
                        AVPacket opkt;
1366
                        av_init_packet(&opkt);
1367

    
1368
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1369
                            continue;
1370

    
1371
                        /* no reencoding needed : output the packet directly */
1372
                        /* force the input stream PTS */
1373

    
1374
                        avcodec_get_frame_defaults(&avframe);
1375
                        ost->st->codec->coded_frame= &avframe;
1376
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1377

    
1378
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1379
                            audio_size += data_size;
1380
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1381
                            video_size += data_size;
1382
                            ost->sync_opts++;
1383
                        }
1384

    
1385
                        opkt.stream_index= ost->index;
1386
                        if(pkt->pts != AV_NOPTS_VALUE)
1387
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1388
                        else
1389
                            opkt.pts= AV_NOPTS_VALUE;
1390

    
1391
                        if (pkt->dts == AV_NOPTS_VALUE)
1392
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1393
                        else
1394
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1395

    
1396
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1397
                        opkt.flags= pkt->flags;
1398

    
1399
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1400
                        if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1401
                            opkt.destruct= av_destruct_packet;
1402

    
1403
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1404
                        ost->st->codec->frame_number++;
1405
                        ost->frame_number++;
1406
                        av_free_packet(&opkt);
1407
                    }
1408
                }
1409
            }
1410
        av_free(buffer_to_free);
1411
        /* XXX: allocate the subtitles in the codec ? */
1412
        if (subtitle_to_free) {
1413
            if (subtitle_to_free->rects != NULL) {
1414
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1415
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1416
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1417
                    av_freep(&subtitle_to_free->rects[i]);
1418
                }
1419
                av_freep(&subtitle_to_free->rects);
1420
            }
1421
            subtitle_to_free->num_rects = 0;
1422
            subtitle_to_free = NULL;
1423
        }
1424
    }
1425
 discard_packet:
1426
    if (pkt == NULL) {
1427
        /* EOF handling */
1428

    
1429
        for(i=0;i<nb_ostreams;i++) {
1430
            ost = ost_table[i];
1431
            if (ost->source_index == ist_index) {
1432
                AVCodecContext *enc= ost->st->codec;
1433
                os = output_files[ost->file_index];
1434

    
1435
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1436
                    continue;
1437
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1438
                    continue;
1439

    
1440
                if (ost->encoding_needed) {
1441
                    for(;;) {
1442
                        AVPacket pkt;
1443
                        int fifo_bytes;
1444
                        av_init_packet(&pkt);
1445
                        pkt.stream_index= ost->index;
1446

    
1447
                        switch(ost->st->codec->codec_type) {
1448
                        case CODEC_TYPE_AUDIO:
1449
                            fifo_bytes = av_fifo_size(ost->fifo);
1450
                            ret = 0;
1451
                            /* encode any samples remaining in fifo */
1452
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1453
                                int fs_tmp = enc->frame_size;
1454
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1455
                                av_fifo_generic_read(ost->fifo, fifo_bytes, NULL, samples);
1456
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1457
                                enc->frame_size = fs_tmp;
1458
                            }
1459
                            if(ret <= 0) {
1460
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1461
                            }
1462
                            if (ret < 0) {
1463
                                fprintf(stderr, "Audio encoding failed\n");
1464
                                av_exit(1);
1465
                            }
1466
                            audio_size += ret;
1467
                            pkt.flags |= PKT_FLAG_KEY;
1468
                            break;
1469
                        case CODEC_TYPE_VIDEO:
1470
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1471
                            if (ret < 0) {
1472
                                fprintf(stderr, "Video encoding failed\n");
1473
                                av_exit(1);
1474
                            }
1475
                            video_size += ret;
1476
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1477
                                pkt.flags |= PKT_FLAG_KEY;
1478
                            if (ost->logfile && enc->stats_out) {
1479
                                fprintf(ost->logfile, "%s", enc->stats_out);
1480
                            }
1481
                            break;
1482
                        default:
1483
                            ret=-1;
1484
                        }
1485

    
1486
                        if(ret<=0)
1487
                            break;
1488
                        pkt.data= bit_buffer;
1489
                        pkt.size= ret;
1490
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1491
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1492
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1493
                    }
1494
                }
1495
            }
1496
        }
1497
    }
1498

    
1499
    return 0;
1500
 fail_decode:
1501
    return -1;
1502
}
1503

    
1504
static void print_sdp(AVFormatContext **avc, int n)
1505
{
1506
    char sdp[2048];
1507

    
1508
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1509
    printf("SDP:\n%s\n", sdp);
1510
    fflush(stdout);
1511
}
1512

    
1513
static int stream_index_from_inputs(AVFormatContext **input_files,
1514
                                    int nb_input_files,
1515
                                    AVInputFile *file_table,
1516
                                    AVInputStream **ist_table,
1517
                                    enum CodecType type,
1518
                                    int programid)
1519
{
1520
    int p, q, z;
1521
    for(z=0; z<nb_input_files; z++) {
1522
        AVFormatContext *ic = input_files[z];
1523
        for(p=0; p<ic->nb_programs; p++) {
1524
            AVProgram *program = ic->programs[p];
1525
            if(program->id != programid)
1526
                continue;
1527
            for(q=0; q<program->nb_stream_indexes; q++) {
1528
                int sidx = program->stream_index[q];
1529
                int ris = file_table[z].ist_index + sidx;
1530
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1531
                    return ris;
1532
            }
1533
        }
1534
    }
1535

    
1536
    return -1;
1537
}
1538

    
1539
/*
1540
 * The following code is the main loop of the file converter
1541
 */
1542
static int av_encode(AVFormatContext **output_files,
1543
                     int nb_output_files,
1544
                     AVFormatContext **input_files,
1545
                     int nb_input_files,
1546
                     AVStreamMap *stream_maps, int nb_stream_maps)
1547
{
1548
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1549
    AVFormatContext *is, *os;
1550
    AVCodecContext *codec, *icodec;
1551
    AVOutputStream *ost, **ost_table = NULL;
1552
    AVInputStream *ist, **ist_table = NULL;
1553
    AVInputFile *file_table;
1554
    int key;
1555
    int want_sdp = 1;
1556
    uint8_t no_packet[MAX_FILES]={0};
1557
    int no_packet_count=0;
1558

    
1559
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1560
    if (!file_table)
1561
        goto fail;
1562

    
1563
    /* input stream init */
1564
    j = 0;
1565
    for(i=0;i<nb_input_files;i++) {
1566
        is = input_files[i];
1567
        file_table[i].ist_index = j;
1568
        file_table[i].nb_streams = is->nb_streams;
1569
        j += is->nb_streams;
1570
    }
1571
    nb_istreams = j;
1572

    
1573
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1574
    if (!ist_table)
1575
        goto fail;
1576

    
1577
    for(i=0;i<nb_istreams;i++) {
1578
        ist = av_mallocz(sizeof(AVInputStream));
1579
        if (!ist)
1580
            goto fail;
1581
        ist_table[i] = ist;
1582
    }
1583
    j = 0;
1584
    for(i=0;i<nb_input_files;i++) {
1585
        is = input_files[i];
1586
        for(k=0;k<is->nb_streams;k++) {
1587
            ist = ist_table[j++];
1588
            ist->st = is->streams[k];
1589
            ist->file_index = i;
1590
            ist->index = k;
1591
            ist->discard = 1; /* the stream is discarded by default
1592
                                 (changed later) */
1593

    
1594
            if (rate_emu) {
1595
                ist->start = av_gettime();
1596
            }
1597
        }
1598
    }
1599

    
1600
    /* output stream init */
1601
    nb_ostreams = 0;
1602
    for(i=0;i<nb_output_files;i++) {
1603
        os = output_files[i];
1604
        if (!os->nb_streams) {
1605
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1606
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1607
            av_exit(1);
1608
        }
1609
        nb_ostreams += os->nb_streams;
1610
    }
1611
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1612
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1613
        av_exit(1);
1614
    }
1615

    
1616
    /* Sanity check the mapping args -- do the input files & streams exist? */
1617
    for(i=0;i<nb_stream_maps;i++) {
1618
        int fi = stream_maps[i].file_index;
1619
        int si = stream_maps[i].stream_index;
1620

    
1621
        if (fi < 0 || fi > nb_input_files - 1 ||
1622
            si < 0 || si > file_table[fi].nb_streams - 1) {
1623
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1624
            av_exit(1);
1625
        }
1626
        fi = stream_maps[i].sync_file_index;
1627
        si = stream_maps[i].sync_stream_index;
1628
        if (fi < 0 || fi > nb_input_files - 1 ||
1629
            si < 0 || si > file_table[fi].nb_streams - 1) {
1630
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1631
            av_exit(1);
1632
        }
1633
    }
1634

    
1635
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1636
    if (!ost_table)
1637
        goto fail;
1638
    for(i=0;i<nb_ostreams;i++) {
1639
        ost = av_mallocz(sizeof(AVOutputStream));
1640
        if (!ost)
1641
            goto fail;
1642
        ost_table[i] = ost;
1643
    }
1644

    
1645
    n = 0;
1646
    for(k=0;k<nb_output_files;k++) {
1647
        os = output_files[k];
1648
        for(i=0;i<os->nb_streams;i++,n++) {
1649
            int found;
1650
            ost = ost_table[n];
1651
            ost->file_index = k;
1652
            ost->index = i;
1653
            ost->st = os->streams[i];
1654
            if (nb_stream_maps > 0) {
1655
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1656
                    stream_maps[n].stream_index;
1657

    
1658
                /* Sanity check that the stream types match */
1659
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1660
                    int i= ost->file_index;
1661
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1662
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1663
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1664
                        ost->file_index, ost->index);
1665
                    av_exit(1);
1666
                }
1667

    
1668
            } else {
1669
                if(opt_programid) {
1670
                    found = 0;
1671
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1672
                    if(j != -1) {
1673
                        ost->source_index = j;
1674
                        found = 1;
1675
                    }
1676
                } else {
1677
                    /* get corresponding input stream index : we select the first one with the right type */
1678
                    found = 0;
1679
                    for(j=0;j<nb_istreams;j++) {
1680
                        ist = ist_table[j];
1681
                        if (ist->discard &&
1682
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1683
                            ost->source_index = j;
1684
                            found = 1;
1685
                            break;
1686
                        }
1687
                    }
1688
                }
1689

    
1690
                if (!found) {
1691
                    if(! opt_programid) {
1692
                        /* try again and reuse existing stream */
1693
                        for(j=0;j<nb_istreams;j++) {
1694
                            ist = ist_table[j];
1695
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1696
                                ost->source_index = j;
1697
                                found = 1;
1698
                            }
1699
                        }
1700
                    }
1701
                    if (!found) {
1702
                        int i= ost->file_index;
1703
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1704
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1705
                                ost->file_index, ost->index);
1706
                        av_exit(1);
1707
                    }
1708
                }
1709
            }
1710
            ist = ist_table[ost->source_index];
1711
            ist->discard = 0;
1712
            ost->sync_ist = (nb_stream_maps > 0) ?
1713
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1714
                         stream_maps[n].sync_stream_index] : ist;
1715
        }
1716
    }
1717

    
1718
    /* for each output stream, we compute the right encoding parameters */
1719
    for(i=0;i<nb_ostreams;i++) {
1720
        AVMetadataTag *lang;
1721
        ost = ost_table[i];
1722
        os = output_files[ost->file_index];
1723
        ist = ist_table[ost->source_index];
1724

    
1725
        codec = ost->st->codec;
1726
        icodec = ist->st->codec;
1727

    
1728
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1729
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1730
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1731

    
1732
        ost->st->disposition = ist->st->disposition;
1733

    
1734
        if (ost->st->stream_copy) {
1735
            /* if stream_copy is selected, no need to decode or encode */
1736
            codec->codec_id = icodec->codec_id;
1737
            codec->codec_type = icodec->codec_type;
1738

    
1739
            if(!codec->codec_tag){
1740
                if(   !os->oformat->codec_tag
1741
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1742
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1743
                    codec->codec_tag = icodec->codec_tag;
1744
            }
1745

    
1746
            codec->bit_rate = icodec->bit_rate;
1747
            codec->extradata= icodec->extradata;
1748
            codec->extradata_size= icodec->extradata_size;
1749
            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){
1750
                codec->time_base = icodec->time_base;
1751
                codec->time_base.num *= icodec->ticks_per_frame;
1752
            }else
1753
                codec->time_base = ist->st->time_base;
1754
            switch(codec->codec_type) {
1755
            case CODEC_TYPE_AUDIO:
1756
                if(audio_volume != 256) {
1757
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1758
                    av_exit(1);
1759
                }
1760
                codec->channel_layout = icodec->channel_layout;
1761
                codec->sample_rate = icodec->sample_rate;
1762
                codec->channels = icodec->channels;
1763
                codec->frame_size = icodec->frame_size;
1764
                codec->block_align= icodec->block_align;
1765
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1766
                    codec->block_align= 0;
1767
                if(codec->codec_id == CODEC_ID_AC3)
1768
                    codec->block_align= 0;
1769
                break;
1770
            case CODEC_TYPE_VIDEO:
1771
                codec->pix_fmt = icodec->pix_fmt;
1772
                codec->width = icodec->width;
1773
                codec->height = icodec->height;
1774
                codec->has_b_frames = icodec->has_b_frames;
1775
                break;
1776
            case CODEC_TYPE_SUBTITLE:
1777
                codec->width = icodec->width;
1778
                codec->height = icodec->height;
1779
                break;
1780
            default:
1781
                abort();
1782
            }
1783
        } else {
1784
            switch(codec->codec_type) {
1785
            case CODEC_TYPE_AUDIO:
1786
                ost->fifo= av_fifo_alloc(1024);
1787
                if(!ost->fifo)
1788
                    goto fail;
1789
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1790
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1791
                icodec->request_channels = codec->channels;
1792
                ist->decoding_needed = 1;
1793
                ost->encoding_needed = 1;
1794
                break;
1795
            case CODEC_TYPE_VIDEO:
1796
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1797
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1798
                ost->video_resample = ((codec->width != icodec->width -
1799
                                (frame_leftBand + frame_rightBand) +
1800
                                (frame_padleft + frame_padright)) ||
1801
                        (codec->height != icodec->height -
1802
                                (frame_topBand  + frame_bottomBand) +
1803
                                (frame_padtop + frame_padbottom)) ||
1804
                        (codec->pix_fmt != icodec->pix_fmt));
1805
                if (ost->video_crop) {
1806
                    ost->topBand = frame_topBand;
1807
                    ost->leftBand = frame_leftBand;
1808
                }
1809
                if (ost->video_pad) {
1810
                    ost->padtop = frame_padtop;
1811
                    ost->padleft = frame_padleft;
1812
                    ost->padbottom = frame_padbottom;
1813
                    ost->padright = frame_padright;
1814
                    if (!ost->video_resample) {
1815
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1816
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1817
                                         codec->width, codec->height))
1818
                            goto fail;
1819
                    }
1820
                }
1821
                if (ost->video_resample) {
1822
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1823
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1824
                                         codec->width, codec->height)) {
1825
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1826
                        av_exit(1);
1827
                    }
1828
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1829
                    ost->img_resample_ctx = sws_getContext(
1830
                            icodec->width - (frame_leftBand + frame_rightBand),
1831
                            icodec->height - (frame_topBand + frame_bottomBand),
1832
                            icodec->pix_fmt,
1833
                            codec->width - (frame_padleft + frame_padright),
1834
                            codec->height - (frame_padtop + frame_padbottom),
1835
                            codec->pix_fmt,
1836
                            sws_flags, NULL, NULL, NULL);
1837
                    if (ost->img_resample_ctx == NULL) {
1838
                        fprintf(stderr, "Cannot get resampling context\n");
1839
                        av_exit(1);
1840
                    }
1841
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1842
                }
1843
                ost->encoding_needed = 1;
1844
                ist->decoding_needed = 1;
1845
                break;
1846
            case CODEC_TYPE_SUBTITLE:
1847
                ost->encoding_needed = 1;
1848
                ist->decoding_needed = 1;
1849
                break;
1850
            default:
1851
                abort();
1852
                break;
1853
            }
1854
            /* two pass mode */
1855
            if (ost->encoding_needed &&
1856
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1857
                char logfilename[1024];
1858
                FILE *f;
1859
                int size;
1860
                char *logbuffer;
1861

    
1862
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1863
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1864
                         i);
1865
                if (codec->flags & CODEC_FLAG_PASS1) {
1866
                    f = fopen(logfilename, "w");
1867
                    if (!f) {
1868
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1869
                        av_exit(1);
1870
                    }
1871
                    ost->logfile = f;
1872
                } else {
1873
                    /* read the log file */
1874
                    f = fopen(logfilename, "r");
1875
                    if (!f) {
1876
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1877
                        av_exit(1);
1878
                    }
1879
                    fseek(f, 0, SEEK_END);
1880
                    size = ftell(f);
1881
                    fseek(f, 0, SEEK_SET);
1882
                    logbuffer = av_malloc(size + 1);
1883
                    if (!logbuffer) {
1884
                        fprintf(stderr, "Could not allocate log buffer\n");
1885
                        av_exit(1);
1886
                    }
1887
                    size = fread(logbuffer, 1, size, f);
1888
                    fclose(f);
1889
                    logbuffer[size] = '\0';
1890
                    codec->stats_in = logbuffer;
1891
                }
1892
            }
1893
        }
1894
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1895
            int size= codec->width * codec->height;
1896
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1897
        }
1898
    }
1899

    
1900
    if (!bit_buffer)
1901
        bit_buffer = av_malloc(bit_buffer_size);
1902
    if (!bit_buffer)
1903
        goto fail;
1904

    
1905
    /* dump the file output parameters - cannot be done before in case
1906
       of stream copy */
1907
    for(i=0;i<nb_output_files;i++) {
1908
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1909
    }
1910

    
1911
    /* dump the stream mapping */
1912
    if (verbose >= 0) {
1913
        fprintf(stderr, "Stream mapping:\n");
1914
        for(i=0;i<nb_ostreams;i++) {
1915
            ost = ost_table[i];
1916
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1917
                    ist_table[ost->source_index]->file_index,
1918
                    ist_table[ost->source_index]->index,
1919
                    ost->file_index,
1920
                    ost->index);
1921
            if (ost->sync_ist != ist_table[ost->source_index])
1922
                fprintf(stderr, " [sync #%d.%d]",
1923
                        ost->sync_ist->file_index,
1924
                        ost->sync_ist->index);
1925
            fprintf(stderr, "\n");
1926
        }
1927
    }
1928

    
1929
    /* open each encoder */
1930
    for(i=0;i<nb_ostreams;i++) {
1931
        ost = ost_table[i];
1932
        if (ost->encoding_needed) {
1933
            AVCodec *codec = output_codecs[i];
1934
            if (!codec)
1935
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
1936
            if (!codec) {
1937
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1938
                        ost->file_index, ost->index);
1939
                av_exit(1);
1940
            }
1941
            if (avcodec_open(ost->st->codec, codec) < 0) {
1942
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1943
                        ost->file_index, ost->index);
1944
                av_exit(1);
1945
            }
1946
            extra_size += ost->st->codec->extradata_size;
1947
        }
1948
    }
1949

    
1950
    /* open each decoder */
1951
    for(i=0;i<nb_istreams;i++) {
1952
        ist = ist_table[i];
1953
        if (ist->decoding_needed) {
1954
            AVCodec *codec = input_codecs[i];
1955
            if (!codec)
1956
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
1957
            if (!codec) {
1958
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1959
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1960
                av_exit(1);
1961
            }
1962
            if (avcodec_open(ist->st->codec, codec) < 0) {
1963
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1964
                        ist->file_index, ist->index);
1965
                av_exit(1);
1966
            }
1967
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1968
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1969
        }
1970
    }
1971

    
1972
    /* init pts */
1973
    for(i=0;i<nb_istreams;i++) {
1974
        ist = ist_table[i];
1975
        is = input_files[ist->file_index];
1976
        ist->pts = 0;
1977
        ist->next_pts = AV_NOPTS_VALUE;
1978
        ist->is_start = 1;
1979
    }
1980

    
1981
    /* set meta data information from input file if required */
1982
    for (i=0;i<nb_meta_data_maps;i++) {
1983
        AVFormatContext *out_file;
1984
        AVFormatContext *in_file;
1985
        AVMetadataTag *mtag;
1986

    
1987
        int out_file_index = meta_data_maps[i].out_file;
1988
        int in_file_index = meta_data_maps[i].in_file;
1989
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1990
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1991
            ret = AVERROR(EINVAL);
1992
            goto fail;
1993
        }
1994
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1995
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1996
            ret = AVERROR(EINVAL);
1997
            goto fail;
1998
        }
1999

    
2000
        out_file = output_files[out_file_index];
2001
        in_file = input_files[in_file_index];
2002

    
2003

    
2004
        mtag=NULL;
2005
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2006
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2007
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2008
                                    in_file->iformat->metadata_conv);
2009
    }
2010

    
2011
    /* open files and write file headers */
2012
    for(i=0;i<nb_output_files;i++) {
2013
        os = output_files[i];
2014
        if (av_write_header(os) < 0) {
2015
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
2016
            ret = AVERROR(EINVAL);
2017
            goto fail;
2018
        }
2019
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2020
            want_sdp = 0;
2021
        }
2022
    }
2023
    if (want_sdp) {
2024
        print_sdp(output_files, nb_output_files);
2025
    }
2026

    
2027
    if (!using_stdin && verbose >= 0) {
2028
        fprintf(stderr, "Press [q] to stop encoding\n");
2029
        url_set_interrupt_cb(decode_interrupt_cb);
2030
    }
2031
    term_init();
2032

    
2033
    key = -1;
2034
    timer_start = av_gettime();
2035

    
2036
    for(; received_sigterm == 0;) {
2037
        int file_index, ist_index;
2038
        AVPacket pkt;
2039
        double ipts_min;
2040
        double opts_min;
2041

    
2042
    redo:
2043
        ipts_min= 1e100;
2044
        opts_min= 1e100;
2045
        /* if 'q' pressed, exits */
2046
        if (!using_stdin) {
2047
            if (q_pressed)
2048
                break;
2049
            /* read_key() returns 0 on EOF */
2050
            key = read_key();
2051
            if (key == 'q')
2052
                break;
2053
        }
2054

    
2055
        /* select the stream that we must read now by looking at the
2056
           smallest output pts */
2057
        file_index = -1;
2058
        for(i=0;i<nb_ostreams;i++) {
2059
            double ipts, opts;
2060
            ost = ost_table[i];
2061
            os = output_files[ost->file_index];
2062
            ist = ist_table[ost->source_index];
2063
            if(no_packet[ist->file_index])
2064
                continue;
2065
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2066
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2067
            else
2068
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2069
            ipts = (double)ist->pts;
2070
            if (!file_table[ist->file_index].eof_reached){
2071
                if(ipts < ipts_min) {
2072
                    ipts_min = ipts;
2073
                    if(input_sync ) file_index = ist->file_index;
2074
                }
2075
                if(opts < opts_min) {
2076
                    opts_min = opts;
2077
                    if(!input_sync) file_index = ist->file_index;
2078
                }
2079
            }
2080
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2081
                file_index= -1;
2082
                break;
2083
            }
2084
        }
2085
        /* if none, if is finished */
2086
        if (file_index < 0) {
2087
            if(no_packet_count){
2088
                no_packet_count=0;
2089
                memset(no_packet, 0, sizeof(no_packet));
2090
                usleep(10000);
2091
                continue;
2092
            }
2093
            break;
2094
        }
2095

    
2096
        /* finish if recording time exhausted */
2097
        if (opts_min >= (recording_time / 1000000.0))
2098
            break;
2099

    
2100
        /* finish if limit size exhausted */
2101
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2102
            break;
2103

    
2104
        /* read a frame from it and output it in the fifo */
2105
        is = input_files[file_index];
2106
        ret= av_read_frame(is, &pkt);
2107
        if(ret == AVERROR(EAGAIN) && strcmp(is->iformat->name, "ffm")){
2108
            no_packet[file_index]=1;
2109
            no_packet_count++;
2110
            continue;
2111
        }
2112
        if (ret < 0) {
2113
            file_table[file_index].eof_reached = 1;
2114
            if (opt_shortest)
2115
                break;
2116
            else
2117
                continue;
2118
        }
2119

    
2120
        no_packet_count=0;
2121
        memset(no_packet, 0, sizeof(no_packet));
2122

    
2123
        if (do_pkt_dump) {
2124
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2125
        }
2126
        /* the following test is needed in case new streams appear
2127
           dynamically in stream : we ignore them */
2128
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2129
            goto discard_packet;
2130
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2131
        ist = ist_table[ist_index];
2132
        if (ist->discard)
2133
            goto discard_packet;
2134

    
2135
        if (pkt.dts != AV_NOPTS_VALUE)
2136
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2137
        if (pkt.pts != AV_NOPTS_VALUE)
2138
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2139

    
2140
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2141
            if(pkt.pts != AV_NOPTS_VALUE)
2142
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2143
            if(pkt.dts != AV_NOPTS_VALUE)
2144
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2145
        }
2146

    
2147
//        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);
2148
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2149
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2150
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2151
            int64_t delta= pkt_dts - ist->next_pts;
2152
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2153
                input_files_ts_offset[ist->file_index]-= delta;
2154
                if (verbose > 2)
2155
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2156
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2157
                if(pkt.pts != AV_NOPTS_VALUE)
2158
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2159
            }
2160
        }
2161

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

    
2165
            if (verbose >= 0)
2166
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2167
                        ist->file_index, ist->index);
2168
            if (exit_on_error)
2169
                av_exit(1);
2170
            av_free_packet(&pkt);
2171
            goto redo;
2172
        }
2173

    
2174
    discard_packet:
2175
        av_free_packet(&pkt);
2176

    
2177
        /* dump report by using the output first video and audio streams */
2178
        print_report(output_files, ost_table, nb_ostreams, 0);
2179
    }
2180

    
2181
    /* at the end of stream, we must flush the decoder buffers */
2182
    for(i=0;i<nb_istreams;i++) {
2183
        ist = ist_table[i];
2184
        if (ist->decoding_needed) {
2185
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2186
        }
2187
    }
2188

    
2189
    term_exit();
2190

    
2191
    /* write the trailer if needed and close file */
2192
    for(i=0;i<nb_output_files;i++) {
2193
        os = output_files[i];
2194
        av_write_trailer(os);
2195
    }
2196

    
2197
    /* dump report by using the first video and audio streams */
2198
    print_report(output_files, ost_table, nb_ostreams, 1);
2199

    
2200
    /* close each encoder */
2201
    for(i=0;i<nb_ostreams;i++) {
2202
        ost = ost_table[i];
2203
        if (ost->encoding_needed) {
2204
            av_freep(&ost->st->codec->stats_in);
2205
            avcodec_close(ost->st->codec);
2206
        }
2207
    }
2208

    
2209
    /* close each decoder */
2210
    for(i=0;i<nb_istreams;i++) {
2211
        ist = ist_table[i];
2212
        if (ist->decoding_needed) {
2213
            avcodec_close(ist->st->codec);
2214
        }
2215
    }
2216

    
2217
    /* finished ! */
2218

    
2219
    ret = 0;
2220
 fail1:
2221
    av_freep(&bit_buffer);
2222
    av_free(file_table);
2223

    
2224
    if (ist_table) {
2225
        for(i=0;i<nb_istreams;i++) {
2226
            ist = ist_table[i];
2227
            av_free(ist);
2228
        }
2229
        av_free(ist_table);
2230
    }
2231
    if (ost_table) {
2232
        for(i=0;i<nb_ostreams;i++) {
2233
            ost = ost_table[i];
2234
            if (ost) {
2235
                if (ost->logfile) {
2236
                    fclose(ost->logfile);
2237
                    ost->logfile = NULL;
2238
                }
2239
                av_fifo_free(ost->fifo); /* works even if fifo is not
2240
                                             initialized but set to zero */
2241
                av_free(ost->pict_tmp.data[0]);
2242
                if (ost->video_resample)
2243
                    sws_freeContext(ost->img_resample_ctx);
2244
                if (ost->resample)
2245
                    audio_resample_close(ost->resample);
2246
                if (ost->reformat_ctx)
2247
                    av_audio_convert_free(ost->reformat_ctx);
2248
                av_free(ost);
2249
            }
2250
        }
2251
        av_free(ost_table);
2252
    }
2253
    return ret;
2254
 fail:
2255
    ret = AVERROR(ENOMEM);
2256
    goto fail1;
2257
}
2258

    
2259
#if 0
2260
int file_read(const char *filename)
2261
{
2262
    URLContext *h;
2263
    unsigned char buffer[1024];
2264
    int len, i;
2265

2266
    if (url_open(&h, filename, O_RDONLY) < 0) {
2267
        printf("could not open '%s'\n", filename);
2268
        return -1;
2269
    }
2270
    for(;;) {
2271
        len = url_read(h, buffer, sizeof(buffer));
2272
        if (len <= 0)
2273
            break;
2274
        for(i=0;i<len;i++) putchar(buffer[i]);
2275
    }
2276
    url_close(h);
2277
    return 0;
2278
}
2279
#endif
2280

    
2281
static void opt_format(const char *arg)
2282
{
2283
    /* compatibility stuff for pgmyuv */
2284
    if (!strcmp(arg, "pgmyuv")) {
2285
        pgmyuv_compatibility_hack=1;
2286
//        opt_image_format(arg);
2287
        arg = "image2";
2288
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2289
    }
2290

    
2291
    file_iformat = av_find_input_format(arg);
2292
    file_oformat = guess_format(arg, NULL, NULL);
2293
    if (!file_iformat && !file_oformat) {
2294
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2295
        av_exit(1);
2296
    }
2297
}
2298

    
2299
static void opt_video_rc_override_string(const char *arg)
2300
{
2301
    video_rc_override_string = arg;
2302
}
2303

    
2304
static int opt_me_threshold(const char *opt, const char *arg)
2305
{
2306
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2307
    return 0;
2308
}
2309

    
2310
static int opt_verbose(const char *opt, const char *arg)
2311
{
2312
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2313
    av_log_set_level(verbose);
2314
    return 0;
2315
}
2316

    
2317
static int opt_frame_rate(const char *opt, const char *arg)
2318
{
2319
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2320
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2321
        av_exit(1);
2322
    }
2323
    return 0;
2324
}
2325

    
2326
static int opt_bitrate(const char *opt, const char *arg)
2327
{
2328
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2329

    
2330
    opt_default(opt, arg);
2331

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

    
2335
    return 0;
2336
}
2337

    
2338
static void opt_frame_crop_top(const char *arg)
2339
{
2340
    frame_topBand = atoi(arg);
2341
    if (frame_topBand < 0) {
2342
        fprintf(stderr, "Incorrect top crop size\n");
2343
        av_exit(1);
2344
    }
2345
    if ((frame_topBand % 2) != 0) {
2346
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2347
        av_exit(1);
2348
    }
2349
    if ((frame_topBand) >= frame_height){
2350
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2351
        av_exit(1);
2352
    }
2353
    frame_height -= frame_topBand;
2354
}
2355

    
2356
static void opt_frame_crop_bottom(const char *arg)
2357
{
2358
    frame_bottomBand = atoi(arg);
2359
    if (frame_bottomBand < 0) {
2360
        fprintf(stderr, "Incorrect bottom crop size\n");
2361
        av_exit(1);
2362
    }
2363
    if ((frame_bottomBand % 2) != 0) {
2364
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2365
        av_exit(1);
2366
    }
2367
    if ((frame_bottomBand) >= frame_height){
2368
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2369
        av_exit(1);
2370
    }
2371
    frame_height -= frame_bottomBand;
2372
}
2373

    
2374
static void opt_frame_crop_left(const char *arg)
2375
{
2376
    frame_leftBand = atoi(arg);
2377
    if (frame_leftBand < 0) {
2378
        fprintf(stderr, "Incorrect left crop size\n");
2379
        av_exit(1);
2380
    }
2381
    if ((frame_leftBand % 2) != 0) {
2382
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2383
        av_exit(1);
2384
    }
2385
    if ((frame_leftBand) >= frame_width){
2386
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2387
        av_exit(1);
2388
    }
2389
    frame_width -= frame_leftBand;
2390
}
2391

    
2392
static void opt_frame_crop_right(const char *arg)
2393
{
2394
    frame_rightBand = atoi(arg);
2395
    if (frame_rightBand < 0) {
2396
        fprintf(stderr, "Incorrect right crop size\n");
2397
        av_exit(1);
2398
    }
2399
    if ((frame_rightBand % 2) != 0) {
2400
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2401
        av_exit(1);
2402
    }
2403
    if ((frame_rightBand) >= frame_width){
2404
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2405
        av_exit(1);
2406
    }
2407
    frame_width -= frame_rightBand;
2408
}
2409

    
2410
static void opt_frame_size(const char *arg)
2411
{
2412
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2413
        fprintf(stderr, "Incorrect frame size\n");
2414
        av_exit(1);
2415
    }
2416
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2417
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2418
        av_exit(1);
2419
    }
2420
}
2421

    
2422

    
2423
#define SCALEBITS 10
2424
#define ONE_HALF  (1 << (SCALEBITS - 1))
2425
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2426

    
2427
#define RGB_TO_Y(r, g, b) \
2428
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2429
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2430

    
2431
#define RGB_TO_U(r1, g1, b1, shift)\
2432
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2433
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2434

    
2435
#define RGB_TO_V(r1, g1, b1, shift)\
2436
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2437
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2438

    
2439
static void opt_pad_color(const char *arg) {
2440
    /* Input is expected to be six hex digits similar to
2441
       how colors are expressed in html tags (but without the #) */
2442
    int rgb = strtol(arg, NULL, 16);
2443
    int r,g,b;
2444

    
2445
    r = (rgb >> 16);
2446
    g = ((rgb >> 8) & 255);
2447
    b = (rgb & 255);
2448

    
2449
    padcolor[0] = RGB_TO_Y(r,g,b);
2450
    padcolor[1] = RGB_TO_U(r,g,b,0);
2451
    padcolor[2] = RGB_TO_V(r,g,b,0);
2452
}
2453

    
2454
static void opt_frame_pad_top(const char *arg)
2455
{
2456
    frame_padtop = atoi(arg);
2457
    if (frame_padtop < 0) {
2458
        fprintf(stderr, "Incorrect top pad size\n");
2459
        av_exit(1);
2460
    }
2461
    if ((frame_padtop % 2) != 0) {
2462
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2463
        av_exit(1);
2464
    }
2465
}
2466

    
2467
static void opt_frame_pad_bottom(const char *arg)
2468
{
2469
    frame_padbottom = atoi(arg);
2470
    if (frame_padbottom < 0) {
2471
        fprintf(stderr, "Incorrect bottom pad size\n");
2472
        av_exit(1);
2473
    }
2474
    if ((frame_padbottom % 2) != 0) {
2475
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2476
        av_exit(1);
2477
    }
2478
}
2479

    
2480

    
2481
static void opt_frame_pad_left(const char *arg)
2482
{
2483
    frame_padleft = atoi(arg);
2484
    if (frame_padleft < 0) {
2485
        fprintf(stderr, "Incorrect left pad size\n");
2486
        av_exit(1);
2487
    }
2488
    if ((frame_padleft % 2) != 0) {
2489
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2490
        av_exit(1);
2491
    }
2492
}
2493

    
2494

    
2495
static void opt_frame_pad_right(const char *arg)
2496
{
2497
    frame_padright = atoi(arg);
2498
    if (frame_padright < 0) {
2499
        fprintf(stderr, "Incorrect right pad size\n");
2500
        av_exit(1);
2501
    }
2502
    if ((frame_padright % 2) != 0) {
2503
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2504
        av_exit(1);
2505
    }
2506
}
2507

    
2508
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2509
{
2510
    int i;
2511
    char fmt_str[128];
2512
    for (i=-1; i < nb_fmts; i++) {
2513
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2514
        fprintf(stdout, "%s\n", fmt_str);
2515
    }
2516
}
2517

    
2518
static void opt_frame_pix_fmt(const char *arg)
2519
{
2520
    if (strcmp(arg, "list"))
2521
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2522
    else {
2523
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2524
        av_exit(0);
2525
    }
2526
}
2527

    
2528
static void opt_frame_aspect_ratio(const char *arg)
2529
{
2530
    int x = 0, y = 0;
2531
    double ar = 0;
2532
    const char *p;
2533
    char *end;
2534

    
2535
    p = strchr(arg, ':');
2536
    if (p) {
2537
        x = strtol(arg, &end, 10);
2538
        if (end == p)
2539
            y = strtol(end+1, &end, 10);
2540
        if (x > 0 && y > 0)
2541
            ar = (double)x / (double)y;
2542
    } else
2543
        ar = strtod(arg, NULL);
2544

    
2545
    if (!ar) {
2546
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2547
        av_exit(1);
2548
    }
2549
    frame_aspect_ratio = ar;
2550
}
2551

    
2552
static int opt_metadata(const char *opt, const char *arg)
2553
{
2554
    char *mid= strchr(arg, '=');
2555

    
2556
    if(!mid){
2557
        fprintf(stderr, "Missing =\n");
2558
        av_exit(1);
2559
    }
2560
    *mid++= 0;
2561

    
2562
    metadata_count++;
2563
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2564
    metadata[metadata_count-1].key  = av_strdup(arg);
2565
    metadata[metadata_count-1].value= av_strdup(mid);
2566

    
2567
    return 0;
2568
}
2569

    
2570
static void opt_qscale(const char *arg)
2571
{
2572
    video_qscale = atof(arg);
2573
    if (video_qscale <= 0 ||
2574
        video_qscale > 255) {
2575
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2576
        av_exit(1);
2577
    }
2578
}
2579

    
2580
static void opt_top_field_first(const char *arg)
2581
{
2582
    top_field_first= atoi(arg);
2583
}
2584

    
2585
static int opt_thread_count(const char *opt, const char *arg)
2586
{
2587
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2588
#if !HAVE_THREADS
2589
    if (verbose >= 0)
2590
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2591
#endif
2592
    return 0;
2593
}
2594

    
2595
static void opt_audio_sample_fmt(const char *arg)
2596
{
2597
    if (strcmp(arg, "list"))
2598
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2599
    else {
2600
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2601
        av_exit(0);
2602
    }
2603
}
2604

    
2605
static int opt_audio_rate(const char *opt, const char *arg)
2606
{
2607
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2608
    return 0;
2609
}
2610

    
2611
static int opt_audio_channels(const char *opt, const char *arg)
2612
{
2613
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2614
    return 0;
2615
}
2616

    
2617
static void opt_video_channel(const char *arg)
2618
{
2619
    video_channel = strtol(arg, NULL, 0);
2620
}
2621

    
2622
static void opt_video_standard(const char *arg)
2623
{
2624
    video_standard = av_strdup(arg);
2625
}
2626

    
2627
static void opt_codec(int *pstream_copy, char **pcodec_name,
2628
                      int codec_type, const char *arg)
2629
{
2630
    av_freep(pcodec_name);
2631
    if (!strcmp(arg, "copy")) {
2632
        *pstream_copy = 1;
2633
    } else {
2634
        *pcodec_name = av_strdup(arg);
2635
    }
2636
}
2637

    
2638
static void opt_audio_codec(const char *arg)
2639
{
2640
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2641
}
2642

    
2643
static void opt_audio_tag(const char *arg)
2644
{
2645
    char *tail;
2646
    audio_codec_tag= strtol(arg, &tail, 0);
2647

    
2648
    if(!tail || *tail)
2649
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2650
}
2651

    
2652
static void opt_video_tag(const char *arg)
2653
{
2654
    char *tail;
2655
    video_codec_tag= strtol(arg, &tail, 0);
2656

    
2657
    if(!tail || *tail)
2658
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2659
}
2660

    
2661
static void opt_video_codec(const char *arg)
2662
{
2663
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2664
}
2665

    
2666
static void opt_subtitle_codec(const char *arg)
2667
{
2668
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2669
}
2670

    
2671
static void opt_map(const char *arg)
2672
{
2673
    AVStreamMap *m;
2674
    char *p;
2675

    
2676
    m = &stream_maps[nb_stream_maps++];
2677

    
2678
    m->file_index = strtol(arg, &p, 0);
2679
    if (*p)
2680
        p++;
2681

    
2682
    m->stream_index = strtol(p, &p, 0);
2683
    if (*p) {
2684
        p++;
2685
        m->sync_file_index = strtol(p, &p, 0);
2686
        if (*p)
2687
            p++;
2688
        m->sync_stream_index = strtol(p, &p, 0);
2689
    } else {
2690
        m->sync_file_index = m->file_index;
2691
        m->sync_stream_index = m->stream_index;
2692
    }
2693
}
2694

    
2695
static void opt_map_meta_data(const char *arg)
2696
{
2697
    AVMetaDataMap *m;
2698
    char *p;
2699

    
2700
    m = &meta_data_maps[nb_meta_data_maps++];
2701

    
2702
    m->out_file = strtol(arg, &p, 0);
2703
    if (*p)
2704
        p++;
2705

    
2706
    m->in_file = strtol(p, &p, 0);
2707
}
2708

    
2709
static void opt_input_ts_scale(const char *arg)
2710
{
2711
    unsigned int stream;
2712
    double scale;
2713
    char *p;
2714

    
2715
    stream = strtol(arg, &p, 0);
2716
    if (*p)
2717
        p++;
2718
    scale= strtod(p, &p);
2719

    
2720
    if(stream >= MAX_STREAMS)
2721
        av_exit(1);
2722

    
2723
    input_files_ts_scale[nb_input_files][stream]= scale;
2724
}
2725

    
2726
static int opt_recording_time(const char *opt, const char *arg)
2727
{
2728
    recording_time = parse_time_or_die(opt, arg, 1);
2729
    return 0;
2730
}
2731

    
2732
static int opt_start_time(const char *opt, const char *arg)
2733
{
2734
    start_time = parse_time_or_die(opt, arg, 1);
2735
    return 0;
2736
}
2737

    
2738
static int opt_rec_timestamp(const char *opt, const char *arg)
2739
{
2740
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2741
    return 0;
2742
}
2743

    
2744
static int opt_input_ts_offset(const char *opt, const char *arg)
2745
{
2746
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2747
    return 0;
2748
}
2749

    
2750
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2751
{
2752
    const char *codec_string = encoder ? "encoder" : "decoder";
2753
    AVCodec *codec;
2754

    
2755
    if(!name)
2756
        return CODEC_ID_NONE;
2757
    codec = encoder ?
2758
        avcodec_find_encoder_by_name(name) :
2759
        avcodec_find_decoder_by_name(name);
2760
    if(!codec) {
2761
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2762
        av_exit(1);
2763
    }
2764
    if(codec->type != type) {
2765
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2766
        av_exit(1);
2767
    }
2768
    return codec->id;
2769
}
2770

    
2771
static void opt_input_file(const char *filename)
2772
{
2773
    AVFormatContext *ic;
2774
    AVFormatParameters params, *ap = &params;
2775
    int err, i, ret, rfps, rfps_base;
2776
    int64_t timestamp;
2777

    
2778
    if (!strcmp(filename, "-"))
2779
        filename = "pipe:";
2780

    
2781
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2782
                    !strcmp(filename, "/dev/stdin");
2783

    
2784
    /* get default parameters from command line */
2785
    ic = avformat_alloc_context();
2786

    
2787
    memset(ap, 0, sizeof(*ap));
2788
    ap->prealloced_context = 1;
2789
    ap->sample_rate = audio_sample_rate;
2790
    ap->channels = audio_channels;
2791
    ap->time_base.den = frame_rate.num;
2792
    ap->time_base.num = frame_rate.den;
2793
    ap->width = frame_width + frame_padleft + frame_padright;
2794
    ap->height = frame_height + frame_padtop + frame_padbottom;
2795
    ap->pix_fmt = frame_pix_fmt;
2796
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2797
    ap->channel = video_channel;
2798
    ap->standard = video_standard;
2799
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2800
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2801
    if(pgmyuv_compatibility_hack)
2802
        ap->video_codec_id= CODEC_ID_PGMYUV;
2803

    
2804
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2805

    
2806
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2807
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2808
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2809
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2810

    
2811
    /* open the input file with generic libav function */
2812
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2813
    if (err < 0) {
2814
        print_error(filename, err);
2815
        av_exit(1);
2816
    }
2817
    if(opt_programid) {
2818
        int i;
2819
        for(i=0; i<ic->nb_programs; i++)
2820
            if(ic->programs[i]->id != opt_programid)
2821
                ic->programs[i]->discard = AVDISCARD_ALL;
2822
    }
2823

    
2824
    ic->loop_input = loop_input;
2825

    
2826
    /* If not enough info to get the stream parameters, we decode the
2827
       first frames to get it. (used in mpeg case for example) */
2828
    ret = av_find_stream_info(ic);
2829
    if (ret < 0 && verbose >= 0) {
2830
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2831
        av_exit(1);
2832
    }
2833

    
2834
    timestamp = start_time;
2835
    /* add the stream start time */
2836
    if (ic->start_time != AV_NOPTS_VALUE)
2837
        timestamp += ic->start_time;
2838

    
2839
    /* if seeking requested, we execute it */
2840
    if (start_time != 0) {
2841
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2842
        if (ret < 0) {
2843
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2844
                    filename, (double)timestamp / AV_TIME_BASE);
2845
        }
2846
        /* reset seek info */
2847
        start_time = 0;
2848
    }
2849

    
2850
    /* update the current parameters so that they match the one of the input stream */
2851
    for(i=0;i<ic->nb_streams;i++) {
2852
        AVCodecContext *enc = ic->streams[i]->codec;
2853
        if(thread_count>1)
2854
            avcodec_thread_init(enc, thread_count);
2855
        enc->thread_count= thread_count;
2856
        switch(enc->codec_type) {
2857
        case CODEC_TYPE_AUDIO:
2858
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2859
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2860
            channel_layout = enc->channel_layout;
2861
            audio_channels = enc->channels;
2862
            audio_sample_rate = enc->sample_rate;
2863
            audio_sample_fmt = enc->sample_fmt;
2864
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2865
            if(audio_disable)
2866
                ic->streams[i]->discard= AVDISCARD_ALL;
2867
            break;
2868
        case CODEC_TYPE_VIDEO:
2869
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2870
            frame_height = enc->height;
2871
            frame_width = enc->width;
2872
            if(ic->streams[i]->sample_aspect_ratio.num)
2873
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2874
            else
2875
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2876
            frame_aspect_ratio *= (float) enc->width / enc->height;
2877
            frame_pix_fmt = enc->pix_fmt;
2878
            rfps      = ic->streams[i]->r_frame_rate.num;
2879
            rfps_base = ic->streams[i]->r_frame_rate.den;
2880
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2881
            if(me_threshold)
2882
                enc->debug |= FF_DEBUG_MV;
2883

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

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

    
2890
                    (float)rfps / rfps_base, rfps, rfps_base);
2891
            }
2892
            /* update the current frame rate to match the stream frame rate */
2893
            frame_rate.num = rfps;
2894
            frame_rate.den = rfps_base;
2895

    
2896
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2897
            if(video_disable)
2898
                ic->streams[i]->discard= AVDISCARD_ALL;
2899
            else if(video_discard)
2900
                ic->streams[i]->discard= video_discard;
2901
            break;
2902
        case CODEC_TYPE_DATA:
2903
            break;
2904
        case CODEC_TYPE_SUBTITLE:
2905
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2906
            if(subtitle_disable)
2907
                ic->streams[i]->discard = AVDISCARD_ALL;
2908
            break;
2909
        case CODEC_TYPE_ATTACHMENT:
2910
        case CODEC_TYPE_UNKNOWN:
2911
            nb_icodecs++;
2912
            break;
2913
        default:
2914
            abort();
2915
        }
2916
    }
2917

    
2918
    input_files[nb_input_files] = ic;
2919
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2920
    /* dump the file content */
2921
    if (verbose >= 0)
2922
        dump_format(ic, nb_input_files, filename, 0);
2923

    
2924
    nb_input_files++;
2925
    file_iformat = NULL;
2926
    file_oformat = NULL;
2927

    
2928
    video_channel = 0;
2929

    
2930
    av_freep(&video_codec_name);
2931
    av_freep(&audio_codec_name);
2932
    av_freep(&subtitle_codec_name);
2933
}
2934

    
2935
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2936
                                         int *has_subtitle_ptr)
2937
{
2938
    int has_video, has_audio, has_subtitle, i, j;
2939
    AVFormatContext *ic;
2940

    
2941
    has_video = 0;
2942
    has_audio = 0;
2943
    has_subtitle = 0;
2944
    for(j=0;j<nb_input_files;j++) {
2945
        ic = input_files[j];
2946
        for(i=0;i<ic->nb_streams;i++) {
2947
            AVCodecContext *enc = ic->streams[i]->codec;
2948
            switch(enc->codec_type) {
2949
            case CODEC_TYPE_AUDIO:
2950
                has_audio = 1;
2951
                break;
2952
            case CODEC_TYPE_VIDEO:
2953
                has_video = 1;
2954
                break;
2955
            case CODEC_TYPE_SUBTITLE:
2956
                has_subtitle = 1;
2957
                break;
2958
            case CODEC_TYPE_DATA:
2959
            case CODEC_TYPE_ATTACHMENT:
2960
            case CODEC_TYPE_UNKNOWN:
2961
                break;
2962
            default:
2963
                abort();
2964
            }
2965
        }
2966
    }
2967
    *has_video_ptr = has_video;
2968
    *has_audio_ptr = has_audio;
2969
    *has_subtitle_ptr = has_subtitle;
2970
}
2971

    
2972
static void new_video_stream(AVFormatContext *oc)
2973
{
2974
    AVStream *st;
2975
    AVCodecContext *video_enc;
2976
    int codec_id;
2977

    
2978
    st = av_new_stream(oc, oc->nb_streams);
2979
    if (!st) {
2980
        fprintf(stderr, "Could not alloc stream\n");
2981
        av_exit(1);
2982
    }
2983
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2984
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2985
    video_bitstream_filters= NULL;
2986

    
2987
    if(thread_count>1)
2988
        avcodec_thread_init(st->codec, thread_count);
2989

    
2990
    video_enc = st->codec;
2991

    
2992
    if(video_codec_tag)
2993
        video_enc->codec_tag= video_codec_tag;
2994

    
2995
    if(   (video_global_header&1)
2996
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2997
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2998
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2999
    }
3000
    if(video_global_header&2){
3001
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3002
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3003
    }
3004

    
3005
    if (video_stream_copy) {
3006
        st->stream_copy = 1;
3007
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3008
        video_enc->sample_aspect_ratio =
3009
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3010
    } else {
3011
        const char *p;
3012
        int i;
3013
        AVCodec *codec;
3014
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3015

    
3016
        if (video_codec_name) {
3017
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3018
            codec = avcodec_find_encoder_by_name(video_codec_name);
3019
            output_codecs[nb_ocodecs] = codec;
3020
        } else {
3021
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3022
            codec = avcodec_find_encoder(codec_id);
3023
        }
3024

    
3025
        video_enc->codec_id = codec_id;
3026

    
3027
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3028

    
3029
        if (codec && codec->supported_framerates && !force_fps)
3030
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3031
        video_enc->time_base.den = fps.num;
3032
        video_enc->time_base.num = fps.den;
3033

    
3034
        video_enc->width = frame_width + frame_padright + frame_padleft;
3035
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3036
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3037
        video_enc->pix_fmt = frame_pix_fmt;
3038
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3039

    
3040
        if(codec && codec->pix_fmts){
3041
            const enum PixelFormat *p= codec->pix_fmts;
3042
            for(; *p!=-1; p++){
3043
                if(*p == video_enc->pix_fmt)
3044
                    break;
3045
            }
3046
            if(*p == -1)
3047
                video_enc->pix_fmt = codec->pix_fmts[0];
3048
        }
3049

    
3050
        if (intra_only)
3051
            video_enc->gop_size = 0;
3052
        if (video_qscale || same_quality) {
3053
            video_enc->flags |= CODEC_FLAG_QSCALE;
3054
            video_enc->global_quality=
3055
                st->quality = FF_QP2LAMBDA * video_qscale;
3056
        }
3057

    
3058
        if(intra_matrix)
3059
            video_enc->intra_matrix = intra_matrix;
3060
        if(inter_matrix)
3061
            video_enc->inter_matrix = inter_matrix;
3062

    
3063
        video_enc->thread_count = thread_count;
3064
        p= video_rc_override_string;
3065
        for(i=0; p; i++){
3066
            int start, end, q;
3067
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3068
            if(e!=3){
3069
                fprintf(stderr, "error parsing rc_override\n");
3070
                av_exit(1);
3071
            }
3072
            video_enc->rc_override=
3073
                av_realloc(video_enc->rc_override,
3074
                           sizeof(RcOverride)*(i+1));
3075
            video_enc->rc_override[i].start_frame= start;
3076
            video_enc->rc_override[i].end_frame  = end;
3077
            if(q>0){
3078
                video_enc->rc_override[i].qscale= q;
3079
                video_enc->rc_override[i].quality_factor= 1.0;
3080
            }
3081
            else{
3082
                video_enc->rc_override[i].qscale= 0;
3083
                video_enc->rc_override[i].quality_factor= -q/100.0;
3084
            }
3085
            p= strchr(p, '/');
3086
            if(p) p++;
3087
        }
3088
        video_enc->rc_override_count=i;
3089
        if (!video_enc->rc_initial_buffer_occupancy)
3090
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3091
        video_enc->me_threshold= me_threshold;
3092
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3093

    
3094
        if (do_psnr)
3095
            video_enc->flags|= CODEC_FLAG_PSNR;
3096

    
3097
        /* two pass mode */
3098
        if (do_pass) {
3099
            if (do_pass == 1) {
3100
                video_enc->flags |= CODEC_FLAG_PASS1;
3101
            } else {
3102
                video_enc->flags |= CODEC_FLAG_PASS2;
3103
            }
3104
        }
3105
    }
3106
    nb_ocodecs++;
3107

    
3108
    /* reset some key parameters */
3109
    video_disable = 0;
3110
    av_freep(&video_codec_name);
3111
    video_stream_copy = 0;
3112
}
3113

    
3114
static void new_audio_stream(AVFormatContext *oc)
3115
{
3116
    AVStream *st;
3117
    AVCodecContext *audio_enc;
3118
    int codec_id;
3119

    
3120
    st = av_new_stream(oc, oc->nb_streams);
3121
    if (!st) {
3122
        fprintf(stderr, "Could not alloc stream\n");
3123
        av_exit(1);
3124
    }
3125
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3126

    
3127
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3128
    audio_bitstream_filters= NULL;
3129

    
3130
    if(thread_count>1)
3131
        avcodec_thread_init(st->codec, thread_count);
3132

    
3133
    audio_enc = st->codec;
3134
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3135

    
3136
    if(audio_codec_tag)
3137
        audio_enc->codec_tag= audio_codec_tag;
3138

    
3139
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3140
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3141
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3142
    }
3143
    if (audio_stream_copy) {
3144
        st->stream_copy = 1;
3145
        audio_enc->channels = audio_channels;
3146
    } else {
3147
        AVCodec *codec;
3148

    
3149
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3150

    
3151
        if (audio_codec_name) {
3152
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3153
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3154
            output_codecs[nb_ocodecs] = codec;
3155
        } else {
3156
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3157
            codec = avcodec_find_encoder(codec_id);
3158
        }
3159
        audio_enc->codec_id = codec_id;
3160

    
3161
        if (audio_qscale > QSCALE_NONE) {
3162
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3163
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3164
        }
3165
        audio_enc->thread_count = thread_count;
3166
        audio_enc->channels = audio_channels;
3167
        audio_enc->sample_fmt = audio_sample_fmt;
3168
        audio_enc->channel_layout = channel_layout;
3169

    
3170
        if(codec && codec->sample_fmts){
3171
            const enum SampleFormat *p= codec->sample_fmts;
3172
            for(; *p!=-1; p++){
3173
                if(*p == audio_enc->sample_fmt)
3174
                    break;
3175
            }
3176
            if(*p == -1)
3177
                audio_enc->sample_fmt = codec->sample_fmts[0];
3178
        }
3179
    }
3180
    nb_ocodecs++;
3181
    audio_enc->sample_rate = audio_sample_rate;
3182
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3183
    if (audio_language) {
3184
        av_metadata_set(&st->metadata, "language", audio_language);
3185
        av_free(audio_language);
3186
        audio_language = NULL;
3187
    }
3188

    
3189
    /* reset some key parameters */
3190
    audio_disable = 0;
3191
    av_freep(&audio_codec_name);
3192
    audio_stream_copy = 0;
3193
}
3194

    
3195
static void new_subtitle_stream(AVFormatContext *oc)
3196
{
3197
    AVStream *st;
3198
    AVCodecContext *subtitle_enc;
3199

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

    
3207
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3208
    subtitle_bitstream_filters= NULL;
3209

    
3210
    subtitle_enc = st->codec;
3211
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3212
    if (subtitle_stream_copy) {
3213
        st->stream_copy = 1;
3214
    } else {
3215
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3216
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3217
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3218
    }
3219
    nb_ocodecs++;
3220

    
3221
    if (subtitle_language) {
3222
        av_metadata_set(&st->metadata, "language", subtitle_language);
3223
        av_free(subtitle_language);
3224
        subtitle_language = NULL;
3225
    }
3226

    
3227
    subtitle_disable = 0;
3228
    av_freep(&subtitle_codec_name);
3229
    subtitle_stream_copy = 0;
3230
}
3231

    
3232
static void opt_new_audio_stream(void)
3233
{
3234
    AVFormatContext *oc;
3235
    if (nb_output_files <= 0) {
3236
        fprintf(stderr, "At least one output file must be specified\n");
3237
        av_exit(1);
3238
    }
3239
    oc = output_files[nb_output_files - 1];
3240
    new_audio_stream(oc);
3241
}
3242

    
3243
static void opt_new_video_stream(void)
3244
{
3245
    AVFormatContext *oc;
3246
    if (nb_output_files <= 0) {
3247
        fprintf(stderr, "At least one output file must be specified\n");
3248
        av_exit(1);
3249
    }
3250
    oc = output_files[nb_output_files - 1];
3251
    new_video_stream(oc);
3252
}
3253

    
3254
static void opt_new_subtitle_stream(void)
3255
{
3256
    AVFormatContext *oc;
3257
    if (nb_output_files <= 0) {
3258
        fprintf(stderr, "At least one output file must be specified\n");
3259
        av_exit(1);
3260
    }
3261
    oc = output_files[nb_output_files - 1];
3262
    new_subtitle_stream(oc);
3263
}
3264

    
3265
static void opt_output_file(const char *filename)
3266
{
3267
    AVFormatContext *oc;
3268
    int use_video, use_audio, use_subtitle;
3269
    int input_has_video, input_has_audio, input_has_subtitle;
3270
    AVFormatParameters params, *ap = &params;
3271

    
3272
    if (!strcmp(filename, "-"))
3273
        filename = "pipe:";
3274

    
3275
    oc = avformat_alloc_context();
3276

    
3277
    if (!file_oformat) {
3278
        file_oformat = guess_format(NULL, filename, NULL);
3279
        if (!file_oformat) {
3280
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3281
                    filename);
3282
            av_exit(1);
3283
        }
3284
    }
3285

    
3286
    oc->oformat = file_oformat;
3287
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3288

    
3289
    if (!strcmp(file_oformat->name, "ffm") &&
3290
        av_strstart(filename, "http:", NULL)) {
3291
        /* special case for files sent to ffserver: we get the stream
3292
           parameters from ffserver */
3293
        int err = read_ffserver_streams(oc, filename);
3294
        if (err < 0) {
3295
            print_error(filename, err);
3296
            av_exit(1);
3297
        }
3298
    } else {
3299
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3300
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3301
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3302

    
3303
        /* disable if no corresponding type found and at least one
3304
           input file */
3305
        if (nb_input_files > 0) {
3306
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3307
                                         &input_has_subtitle);
3308
            if (!input_has_video)
3309
                use_video = 0;
3310
            if (!input_has_audio)
3311
                use_audio = 0;
3312
            if (!input_has_subtitle)
3313
                use_subtitle = 0;
3314
        }
3315

    
3316
        /* manual disable */
3317
        if (audio_disable) {
3318
            use_audio = 0;
3319
        }
3320
        if (video_disable) {
3321
            use_video = 0;
3322
        }
3323
        if (subtitle_disable) {
3324
            use_subtitle = 0;
3325
        }
3326

    
3327
        if (use_video) {
3328
            new_video_stream(oc);
3329
        }
3330

    
3331
        if (use_audio) {
3332
            new_audio_stream(oc);
3333
        }
3334

    
3335
        if (use_subtitle) {
3336
            new_subtitle_stream(oc);
3337
        }
3338

    
3339
        oc->timestamp = rec_timestamp;
3340

    
3341
        for(; metadata_count>0; metadata_count--){
3342
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3343
                                           metadata[metadata_count-1].value);
3344
        }
3345
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3346
    }
3347

    
3348
    output_files[nb_output_files++] = oc;
3349

    
3350
    /* check filename in case of an image number is expected */
3351
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3352
        if (!av_filename_number_test(oc->filename)) {
3353
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3354
            av_exit(1);
3355
        }
3356
    }
3357

    
3358
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3359
        /* test if it already exists to avoid loosing precious files */
3360
        if (!file_overwrite &&
3361
            (strchr(filename, ':') == NULL ||
3362
             filename[1] == ':' ||
3363
             av_strstart(filename, "file:", NULL))) {
3364
            if (url_exist(filename)) {
3365
                int c;
3366

    
3367
                if (!using_stdin) {
3368
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3369
                    fflush(stderr);
3370
                    c = getchar();
3371
                    if (toupper(c) != 'Y') {
3372
                        fprintf(stderr, "Not overwriting - exiting\n");
3373
                        av_exit(1);
3374
                    }
3375
                }
3376
                else {
3377
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3378
                    av_exit(1);
3379
                }
3380
            }
3381
        }
3382

    
3383
        /* open the file */
3384
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3385
            fprintf(stderr, "Could not open '%s'\n", filename);
3386
            av_exit(1);
3387
        }
3388
    }
3389

    
3390
    memset(ap, 0, sizeof(*ap));
3391
    if (av_set_parameters(oc, ap) < 0) {
3392
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3393
                oc->filename);
3394
        av_exit(1);
3395
    }
3396

    
3397
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3398
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3399
    oc->loop_output = loop_output;
3400
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3401

    
3402
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3403

    
3404
    /* reset some options */
3405
    file_oformat = NULL;
3406
    file_iformat = NULL;
3407
}
3408

    
3409
/* same option as mencoder */
3410
static void opt_pass(const char *pass_str)
3411
{
3412
    int pass;
3413
    pass = atoi(pass_str);
3414
    if (pass != 1 && pass != 2) {
3415
        fprintf(stderr, "pass number can be only 1 or 2\n");
3416
        av_exit(1);
3417
    }
3418
    do_pass = pass;
3419
}
3420

    
3421
static int64_t getutime(void)
3422
{
3423
#if HAVE_GETRUSAGE
3424
    struct rusage rusage;
3425

    
3426
    getrusage(RUSAGE_SELF, &rusage);
3427
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3428
#elif HAVE_GETPROCESSTIMES
3429
    HANDLE proc;
3430
    FILETIME c, e, k, u;
3431
    proc = GetCurrentProcess();
3432
    GetProcessTimes(proc, &c, &e, &k, &u);
3433
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3434
#else
3435
    return av_gettime();
3436
#endif
3437
}
3438

    
3439
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3440
{
3441
    int i;
3442
    const char *p = str;
3443
    for(i = 0;; i++) {
3444
        dest[i] = atoi(p);
3445
        if(i == 63)
3446
            break;
3447
        p = strchr(p, ',');
3448
        if(!p) {
3449
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3450
            av_exit(1);
3451
        }
3452
        p++;
3453
    }
3454
}
3455

    
3456
static void opt_inter_matrix(const char *arg)
3457
{
3458
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3459
    parse_matrix_coeffs(inter_matrix, arg);
3460
}
3461

    
3462
static void opt_intra_matrix(const char *arg)
3463
{
3464
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3465
    parse_matrix_coeffs(intra_matrix, arg);
3466
}
3467

    
3468
/**
3469
 * Trivial log callback.
3470
 * Only suitable for show_help and similar since it lacks prefix handling.
3471
 */
3472
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3473
{
3474
    vfprintf(stdout, fmt, vl);
3475
}
3476

    
3477
static void show_help(void)
3478
{
3479
    av_log_set_callback(log_callback_help);
3480
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3481
           "Hyper fast Audio and Video encoder\n");
3482
    printf("\n");
3483
    show_help_options(options, "Main options:\n",
3484
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3485
    show_help_options(options, "\nAdvanced options:\n",
3486
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3487
                      OPT_EXPERT);
3488
    show_help_options(options, "\nVideo options:\n",
3489
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3490
                      OPT_VIDEO);
3491
    show_help_options(options, "\nAdvanced Video options:\n",
3492
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3493
                      OPT_VIDEO | OPT_EXPERT);
3494
    show_help_options(options, "\nAudio options:\n",
3495
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3496
                      OPT_AUDIO);
3497
    show_help_options(options, "\nAdvanced Audio options:\n",
3498
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3499
                      OPT_AUDIO | OPT_EXPERT);
3500
    show_help_options(options, "\nSubtitle options:\n",
3501
                      OPT_SUBTITLE | OPT_GRAB,
3502
                      OPT_SUBTITLE);
3503
    show_help_options(options, "\nAudio/Video grab options:\n",
3504
                      OPT_GRAB,
3505
                      OPT_GRAB);
3506
    printf("\n");
3507
    av_opt_show(avcodec_opts[0], NULL);
3508
    printf("\n");
3509
    av_opt_show(avformat_opts, NULL);
3510
    printf("\n");
3511
    av_opt_show(sws_opts, NULL);
3512
}
3513

    
3514
static void opt_target(const char *arg)
3515
{
3516
    int norm = -1;
3517
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3518

    
3519
    if(!strncmp(arg, "pal-", 4)) {
3520
        norm = 0;
3521
        arg += 4;
3522
    } else if(!strncmp(arg, "ntsc-", 5)) {
3523
        norm = 1;
3524
        arg += 5;
3525
    } else if(!strncmp(arg, "film-", 5)) {
3526
        norm = 2;
3527
        arg += 5;
3528
    } else {
3529
        int fr;
3530
        /* Calculate FR via float to avoid int overflow */
3531
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3532
        if(fr == 25000) {
3533
            norm = 0;
3534
        } else if((fr == 29970) || (fr == 23976)) {
3535
            norm = 1;
3536
        } else {
3537
            /* Try to determine PAL/NTSC by peeking in the input files */
3538
            if(nb_input_files) {
3539
                int i, j;
3540
                for(j = 0; j < nb_input_files; j++) {
3541
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3542
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3543
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3544
                            continue;
3545
                        fr = c->time_base.den * 1000 / c->time_base.num;
3546
                        if(fr == 25000) {
3547
                            norm = 0;
3548
                            break;
3549
                        } else if((fr == 29970) || (fr == 23976)) {
3550
                            norm = 1;
3551
                            break;
3552
                        }
3553
                    }
3554
                    if(norm >= 0)
3555
                        break;
3556
                }
3557
            }
3558
        }
3559
        if(verbose && norm >= 0)
3560
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3561
    }
3562

    
3563
    if(norm < 0) {
3564
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3565
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3566
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3567
        av_exit(1);
3568
    }
3569

    
3570
    if(!strcmp(arg, "vcd")) {
3571

    
3572
        opt_video_codec("mpeg1video");
3573
        opt_audio_codec("mp2");
3574
        opt_format("vcd");
3575

    
3576
        opt_frame_size(norm ? "352x240" : "352x288");
3577
        opt_frame_rate(NULL, frame_rates[norm]);
3578
        opt_default("gop", norm ? "18" : "15");
3579

    
3580
        opt_default("b", "1150000");
3581
        opt_default("maxrate", "1150000");
3582
        opt_default("minrate", "1150000");
3583
        opt_default("bufsize", "327680"); // 40*1024*8;
3584

    
3585
        opt_default("ab", "224000");
3586
        audio_sample_rate = 44100;
3587
        audio_channels = 2;
3588

    
3589
        opt_default("packetsize", "2324");
3590
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3591

    
3592
        /* We have to offset the PTS, so that it is consistent with the SCR.
3593
           SCR starts at 36000, but the first two packs contain only padding
3594
           and the first pack from the other stream, respectively, may also have
3595
           been written before.
3596
           So the real data starts at SCR 36000+3*1200. */
3597
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3598
    } else if(!strcmp(arg, "svcd")) {
3599

    
3600
        opt_video_codec("mpeg2video");
3601
        opt_audio_codec("mp2");
3602
        opt_format("svcd");
3603

    
3604
        opt_frame_size(norm ? "480x480" : "480x576");
3605
        opt_frame_rate(NULL, frame_rates[norm]);
3606
        opt_default("gop", norm ? "18" : "15");
3607

    
3608
        opt_default("b", "2040000");
3609
        opt_default("maxrate", "2516000");
3610
        opt_default("minrate", "0"); //1145000;
3611
        opt_default("bufsize", "1835008"); //224*1024*8;
3612
        opt_default("flags", "+scan_offset");
3613

    
3614

    
3615
        opt_default("ab", "224000");
3616
        audio_sample_rate = 44100;
3617

    
3618
        opt_default("packetsize", "2324");
3619

    
3620
    } else if(!strcmp(arg, "dvd")) {
3621

    
3622
        opt_video_codec("mpeg2video");
3623
        opt_audio_codec("ac3");
3624
        opt_format("dvd");
3625

    
3626
        opt_frame_size(norm ? "720x480" : "720x576");
3627
        opt_frame_rate(NULL, frame_rates[norm]);
3628
        opt_default("gop", norm ? "18" : "15");
3629

    
3630
        opt_default("b", "6000000");
3631
        opt_default("maxrate", "9000000");
3632
        opt_default("minrate", "0"); //1500000;
3633
        opt_default("bufsize", "1835008"); //224*1024*8;
3634

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

    
3638
        opt_default("ab", "448000");
3639
        audio_sample_rate = 48000;
3640

    
3641
    } else if(!strncmp(arg, "dv", 2)) {
3642

    
3643
        opt_format("dv");
3644

    
3645
        opt_frame_size(norm ? "720x480" : "720x576");
3646
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3647
                                             (norm ? "yuv411p" : "yuv420p"));
3648
        opt_frame_rate(NULL, frame_rates[norm]);
3649

    
3650
        audio_sample_rate = 48000;
3651
        audio_channels = 2;
3652

    
3653
    } else {
3654
        fprintf(stderr, "Unknown target: %s\n", arg);
3655
        av_exit(1);
3656
    }
3657
}
3658

    
3659
static void opt_vstats_file (const char *arg)
3660
{
3661
    av_free (vstats_filename);
3662
    vstats_filename=av_strdup (arg);
3663
}
3664

    
3665
static void opt_vstats (void)
3666
{
3667
    char filename[40];
3668
    time_t today2 = time(NULL);
3669
    struct tm *today = localtime(&today2);
3670

    
3671
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3672
             today->tm_sec);
3673
    opt_vstats_file(filename);
3674
}
3675

    
3676
static int opt_bsf(const char *opt, const char *arg)
3677
{
3678
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3679
    AVBitStreamFilterContext **bsfp;
3680

    
3681
    if(!bsfc){
3682
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3683
        av_exit(1);
3684
    }
3685

    
3686
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3687
          *opt == 'a' ? &audio_bitstream_filters :
3688
                        &subtitle_bitstream_filters;
3689
    while(*bsfp)
3690
        bsfp= &(*bsfp)->next;
3691

    
3692
    *bsfp= bsfc;
3693

    
3694
    return 0;
3695
}
3696

    
3697
static int opt_preset(const char *opt, const char *arg)
3698
{
3699
    FILE *f=NULL;
3700
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3701
    int i;
3702
    const char *base[2]= { getenv("HOME"),
3703
                           FFMPEG_DATADIR,
3704
                         };
3705

    
3706
    for(i=!base[0]; i<2 && !f; i++){
3707
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3708
        f= fopen(filename, "r");
3709
        if(!f){
3710
            char *codec_name= *opt == 'v' ? video_codec_name :
3711
                              *opt == 'a' ? audio_codec_name :
3712
                                            subtitle_codec_name;
3713
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3714
            f= fopen(filename, "r");
3715
        }
3716
    }
3717
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3718
              is_dos_path(arg))){
3719
        av_strlcpy(filename, arg, sizeof(filename));
3720
        f= fopen(filename, "r");
3721
    }
3722

    
3723
    if(!f){
3724
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3725
        av_exit(1);
3726
    }
3727

    
3728
    while(!feof(f)){
3729
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3730
        if(line[0] == '#' && !e)
3731
            continue;
3732
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3733
        if(e){
3734
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3735
            av_exit(1);
3736
        }
3737
        if(!strcmp(tmp, "acodec")){
3738
            opt_audio_codec(tmp2);
3739
        }else if(!strcmp(tmp, "vcodec")){
3740
            opt_video_codec(tmp2);
3741
        }else if(!strcmp(tmp, "scodec")){
3742
            opt_subtitle_codec(tmp2);
3743
        }else if(opt_default(tmp, tmp2) < 0){
3744
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3745
            av_exit(1);
3746
        }
3747
    }
3748

    
3749
    fclose(f);
3750

    
3751
    return 0;
3752
}
3753

    
3754
static const OptionDef options[] = {
3755
    /* main options */
3756
    { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3757
    { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3758
    { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3759
    { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3760
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3761
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3762
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3763
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3764
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3765
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3766
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3767
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3768
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3769
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3770
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3771
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)&opt_metadata}, "add metadata", "string=string" },
3772
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3773
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3774
      "add timings for benchmarking" },
3775
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3776
      "dump each input packet" },
3777
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3778
      "when dumping packets, also dump the payload" },
3779
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3780
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3781
    { "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)", "" },
3782
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3783
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3784
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3785
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3786
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3787
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3788
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3789
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3790
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3791
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3792
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3793
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3794
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3795

    
3796
    /* video options */
3797
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3798
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3799
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3800
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3801
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3802
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3803
    { "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" },
3804
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3805
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3806
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3807
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3808
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3809
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3810
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3811
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3812
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3813
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3814
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3815
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3816
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3817
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3818
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3819
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3820
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3821
      "use same video quality as source (implies VBR)" },
3822
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3823
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3824
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3825
      "deinterlace pictures" },
3826
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3827
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3828
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3829
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3830
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3831
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3832
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3833
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3834
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3835
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3836
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3837

    
3838
    /* audio options */
3839
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3840
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3841
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3842
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3843
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3844
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3845
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3846
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3847
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3848
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3849
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3850
    { "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" },
3851

    
3852
    /* subtitle options */
3853
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3854
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3855
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3856
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3857

    
3858
    /* grab options */
3859
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3860
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3861
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3862

    
3863
    /* muxer options */
3864
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3865
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3866

    
3867
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3868
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3869
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3870

    
3871
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3872
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3873
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3874

    
3875
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3876
    { NULL, },
3877
};
3878

    
3879
int main(int argc, char **argv)
3880
{
3881
    int i;
3882
    int64_t ti;
3883

    
3884
    avcodec_register_all();
3885
    avdevice_register_all();
3886
    av_register_all();
3887

    
3888
    if(isatty(STDIN_FILENO))
3889
        url_set_interrupt_cb(decode_interrupt_cb);
3890

    
3891
    for(i=0; i<CODEC_TYPE_NB; i++){
3892
        avcodec_opts[i]= avcodec_alloc_context2(i);
3893
    }
3894
    avformat_opts = avformat_alloc_context();
3895
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3896

    
3897
    show_banner();
3898

    
3899
    /* parse options */
3900
    parse_options(argc, argv, options, opt_output_file);
3901

    
3902
    /* file converter / grab */
3903
    if (nb_output_files <= 0) {
3904
        fprintf(stderr, "At least one output file must be specified\n");
3905
        av_exit(1);
3906
    }
3907

    
3908
    if (nb_input_files == 0) {
3909
        fprintf(stderr, "At least one input file must be specified\n");
3910
        av_exit(1);
3911
    }
3912

    
3913
    ti = getutime();
3914
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3915
                  stream_maps, nb_stream_maps) < 0)
3916
        av_exit(1);
3917
    ti = getutime() - ti;
3918
    if (do_benchmark) {
3919
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3920
    }
3921

    
3922
    return av_exit(0);
3923
}