Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ aa9b754f

History | View | Annotate | Download (140 KB)

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

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

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

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

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

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

    
66
#include "cmdutils.h"
67

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

    
71
#undef exit
72

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

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

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

    
90
static const OptionDef options[];
91

    
92
#define MAX_FILES 20
93

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

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

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

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

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

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

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

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

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

    
198
static int rate_emu = 0;
199

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

    
203
static int audio_volume = 256;
204

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

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

    
222
static unsigned int sws_flags = SWS_BICUBIC;
223

    
224
static int64_t timer_start;
225

    
226
static uint8_t *audio_buf;
227
static uint8_t *audio_out;
228
static uint8_t *audio_out2;
229

    
230
static short *samples;
231

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

    
237
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
238

    
239
struct AVInputStream;
240

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

    
259
    int video_crop;
260
    int topBand;             /* cropping area sizes */
261
    int leftBand;
262

    
263
    int video_pad;
264
    int padtop;              /* padding area sizes */
265
    int padbottom;
266
    int padleft;
267
    int padright;
268

    
269
    /* audio only */
270
    int audio_resample;
271
    ReSampleContext *resample; /* for audio resampling */
272
    int reformat_pair;
273
    AVAudioConvert *reformat_ctx;
274
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
275
    FILE *logfile;
276
} AVOutputStream;
277

    
278
typedef struct AVInputStream {
279
    int file_index;
280
    int index;
281
    AVStream *st;
282
    int discard;             /* true if stream data should be discarded */
283
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
284
    int64_t sample_index;      /* current sample */
285

    
286
    int64_t       start;     /* time when read started */
287
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
288
                                is not defined */
289
    int64_t       pts;       /* current pts */
290
    int is_start;            /* is 1 at the start and after a discontinuity */
291
} AVInputStream;
292

    
293
typedef struct AVInputFile {
294
    int eof_reached;      /* true if eof reached */
295
    int ist_index;        /* index of first stream in ist_table */
296
    int buffer_size;      /* current total buffer size */
297
    int nb_streams;       /* nb streams we are aware of */
298
} AVInputFile;
299

    
300
#if HAVE_TERMIOS_H
301

    
302
/* init terminal so that we can grab keys */
303
static struct termios oldtty;
304
#endif
305

    
306
static void term_exit(void)
307
{
308
#if HAVE_TERMIOS_H
309
    tcsetattr (0, TCSANOW, &oldtty);
310
#endif
311
}
312

    
313
static volatile sig_atomic_t received_sigterm = 0;
314

    
315
static void
316
sigterm_handler(int sig)
317
{
318
    received_sigterm = sig;
319
    term_exit();
320
}
321

    
322
static void term_init(void)
323
{
324
#if HAVE_TERMIOS_H
325
    struct termios tty;
326

    
327
    tcgetattr (0, &tty);
328
    oldtty = tty;
329

    
330
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
331
                          |INLCR|IGNCR|ICRNL|IXON);
332
    tty.c_oflag |= OPOST;
333
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
334
    tty.c_cflag &= ~(CSIZE|PARENB);
335
    tty.c_cflag |= CS8;
336
    tty.c_cc[VMIN] = 1;
337
    tty.c_cc[VTIME] = 0;
338

    
339
    tcsetattr (0, TCSANOW, &tty);
340
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
341
#endif
342

    
343
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
344
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
345
    /*
346
    register a function to be called at normal program termination
347
    */
348
    atexit(term_exit);
349
#if CONFIG_BEOS_NETSERVER
350
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
351
#endif
352
}
353

    
354
/* read a key without blocking */
355
static int read_key(void)
356
{
357
#if HAVE_TERMIOS_H
358
    int n = 1;
359
    unsigned char ch;
360
#if !CONFIG_BEOS_NETSERVER
361
    struct timeval tv;
362
    fd_set rfds;
363

    
364
    FD_ZERO(&rfds);
365
    FD_SET(0, &rfds);
366
    tv.tv_sec = 0;
367
    tv.tv_usec = 0;
368
    n = select(1, &rfds, NULL, NULL, &tv);
369
#endif
370
    if (n > 0) {
371
        n = read(0, &ch, 1);
372
        if (n == 1)
373
            return ch;
374

    
375
        return n;
376
    }
377
#elif HAVE_CONIO_H
378
    if(kbhit())
379
        return(getch());
380
#endif
381
    return -1;
382
}
383

    
384
static int decode_interrupt_cb(void)
385
{
386
    return q_pressed || (q_pressed = read_key() == 'q');
387
}
388

    
389
static int av_exit(int ret)
390
{
391
    int i;
392

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

    
417
    av_free(intra_matrix);
418
    av_free(inter_matrix);
419

    
420
    if (vstats_file)
421
        fclose(vstats_file);
422
    av_free(vstats_filename);
423

    
424
    av_free(opt_names);
425

    
426
    av_free(video_codec_name);
427
    av_free(audio_codec_name);
428
    av_free(subtitle_codec_name);
429

    
430
    av_free(video_standard);
431

    
432
#if CONFIG_POWERPC_PERF
433
    void powerpc_display_perf_report(void);
434
    powerpc_display_perf_report();
435
#endif /* CONFIG_POWERPC_PERF */
436

    
437
    for (i=0;i<CODEC_TYPE_NB;i++)
438
        av_free(avcodec_opts[i]);
439
    av_free(avformat_opts);
440
    av_free(sws_opts);
441
    av_free(audio_buf);
442
    av_free(audio_out);
443
    av_free(audio_out2);
444
    av_free(samples);
445

    
446
    if (received_sigterm) {
447
        fprintf(stderr,
448
            "Received signal %d: terminating.\n",
449
            (int) received_sigterm);
450
        exit (255);
451
    }
452

    
453
    exit(ret); /* not all OS-es handle main() return value */
454
    return ret;
455
}
456

    
457
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
458
{
459
    int i, err;
460
    AVFormatContext *ic;
461
    int nopts = 0;
462

    
463
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
464
    if (err < 0)
465
        return err;
466
    /* copy stream format */
467
    s->nb_streams = ic->nb_streams;
468
    for(i=0;i<ic->nb_streams;i++) {
469
        AVStream *st;
470

    
471
        // FIXME: a more elegant solution is needed
472
        st = av_mallocz(sizeof(AVStream));
473
        memcpy(st, ic->streams[i], sizeof(AVStream));
474
        st->codec = avcodec_alloc_context();
475
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
476
        s->streams[i] = st;
477

    
478
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
479
            st->stream_copy = 1;
480
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
481
            st->stream_copy = 1;
482

    
483
        if(!st->codec->thread_count)
484
            st->codec->thread_count = 1;
485
        if(st->codec->thread_count>1)
486
            avcodec_thread_init(st->codec, st->codec->thread_count);
487

    
488
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
489
            nopts = 1;
490
    }
491

    
492
    if (!nopts)
493
        s->timestamp = av_gettime();
494

    
495
    av_close_input_file(ic);
496
    return 0;
497
}
498

    
499
static double
500
get_sync_ipts(const AVOutputStream *ost)
501
{
502
    const AVInputStream *ist = ost->sync_ist;
503
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
504
}
505

    
506
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
507
    int ret;
508

    
509
    while(bsfc){
510
        AVPacket new_pkt= *pkt;
511
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
512
                                          &new_pkt.data, &new_pkt.size,
513
                                          pkt->data, pkt->size,
514
                                          pkt->flags & PKT_FLAG_KEY);
515
        if(a>0){
516
            av_free_packet(pkt);
517
            new_pkt.destruct= av_destruct_packet;
518
        } else if(a<0){
519
            fprintf(stderr, "%s failed for stream %d, codec %s",
520
                    bsfc->filter->name, pkt->stream_index,
521
                    avctx->codec ? avctx->codec->name : "copy");
522
            print_error("", a);
523
            if (exit_on_error)
524
                av_exit(1);
525
        }
526
        *pkt= new_pkt;
527

    
528
        bsfc= bsfc->next;
529
    }
530

    
531
    ret= av_interleaved_write_frame(s, pkt);
532
    if(ret < 0){
533
        print_error("av_interleaved_write_frame()", ret);
534
        av_exit(1);
535
    }
536
}
537

    
538
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
539

    
540
static void do_audio_out(AVFormatContext *s,
541
                         AVOutputStream *ost,
542
                         AVInputStream *ist,
543
                         unsigned char *buf, int size)
544
{
545
    uint8_t *buftmp;
546
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
547

    
548
    int size_out, frame_bytes, ret;
549
    AVCodecContext *enc= ost->st->codec;
550
    AVCodecContext *dec= ist->st->codec;
551
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
552
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
553

    
554
    /* SC: dynamic allocation of buffers */
555
    if (!audio_buf)
556
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
557
    if (!audio_out)
558
        audio_out = av_malloc(audio_out_size);
559
    if (!audio_buf || !audio_out)
560
        return;               /* Should signal an error ! */
561

    
562
    if (enc->channels != dec->channels)
563
        ost->audio_resample = 1;
564

    
565
    if (ost->audio_resample && !ost->resample) {
566
        if (dec->sample_fmt != SAMPLE_FMT_S16)
567
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
568
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
569
                                               enc->sample_rate, dec->sample_rate,
570
                                               enc->sample_fmt,  dec->sample_fmt,
571
                                               16, 10, 0, 0.8);
572
        if (!ost->resample) {
573
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
574
                    dec->channels, dec->sample_rate,
575
                    enc->channels, enc->sample_rate);
576
            av_exit(1);
577
        }
578
    }
579

    
580
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
581
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
582
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
583
        if (!audio_out2)
584
            audio_out2 = av_malloc(audio_out_size);
585
        if (!audio_out2)
586
            av_exit(1);
587
        if (ost->reformat_ctx)
588
            av_audio_convert_free(ost->reformat_ctx);
589
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
590
                                                   dec->sample_fmt, 1, NULL, 0);
591
        if (!ost->reformat_ctx) {
592
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
593
                avcodec_get_sample_fmt_name(dec->sample_fmt),
594
                avcodec_get_sample_fmt_name(enc->sample_fmt));
595
            av_exit(1);
596
        }
597
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
598
    }
599

    
600
    if(audio_sync_method){
601
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
602
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
603
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
604
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
605

    
606
        //FIXME resample delay
607
        if(fabs(delta) > 50){
608
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
609
                if(byte_delta < 0){
610
                    byte_delta= FFMAX(byte_delta, -size);
611
                    size += byte_delta;
612
                    buf  -= byte_delta;
613
                    if(verbose > 2)
614
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
615
                    if(!size)
616
                        return;
617
                    ist->is_start=0;
618
                }else{
619
                    static uint8_t *input_tmp= NULL;
620
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
621

    
622
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
623
                        ist->is_start=0;
624
                    else
625
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
626

    
627
                    memset(input_tmp, 0, byte_delta);
628
                    memcpy(input_tmp + byte_delta, buf, size);
629
                    buf= input_tmp;
630
                    size += byte_delta;
631
                    if(verbose > 2)
632
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
633
                }
634
            }else if(audio_sync_method>1){
635
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
636
                assert(ost->audio_resample);
637
                if(verbose > 2)
638
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
639
//                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));
640
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
641
            }
642
        }
643
    }else
644
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
645
                        - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
646

    
647
    if (ost->audio_resample) {
648
        buftmp = audio_buf;
649
        size_out = audio_resample(ost->resample,
650
                                  (short *)buftmp, (short *)buf,
651
                                  size / (ist->st->codec->channels * isize));
652
        size_out = size_out * enc->channels * osize;
653
    } else {
654
        buftmp = buf;
655
        size_out = size;
656
    }
657

    
658
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
659
        const void *ibuf[6]= {buftmp};
660
        void *obuf[6]= {audio_out2};
661
        int istride[6]= {isize};
662
        int ostride[6]= {osize};
663
        int len= size_out/istride[0];
664
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
665
            printf("av_audio_convert() failed\n");
666
            if (exit_on_error)
667
                av_exit(1);
668
            return;
669
        }
670
        buftmp = audio_out2;
671
        size_out = len*osize;
672
    }
673

    
674
    /* now encode as many frames as possible */
675
    if (enc->frame_size > 1) {
676
        /* output resampled raw samples */
677
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
678
            fprintf(stderr, "av_fifo_realloc2() failed\n");
679
            av_exit(1);
680
        }
681
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
682

    
683
        frame_bytes = enc->frame_size * osize * enc->channels;
684

    
685
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
686
            AVPacket pkt;
687
            av_init_packet(&pkt);
688

    
689
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
690

    
691
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
692

    
693
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
694
                                       (short *)audio_buf);
695
            if (ret < 0) {
696
                fprintf(stderr, "Audio encoding failed\n");
697
                av_exit(1);
698
            }
699
            audio_size += ret;
700
            pkt.stream_index= ost->index;
701
            pkt.data= audio_out;
702
            pkt.size= ret;
703
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
704
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
705
            pkt.flags |= PKT_FLAG_KEY;
706
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
707

    
708
            ost->sync_opts += enc->frame_size;
709
        }
710
    } else {
711
        AVPacket pkt;
712
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
713
        av_init_packet(&pkt);
714

    
715
        ost->sync_opts += size_out / (osize * enc->channels);
716

    
717
        /* output a pcm frame */
718
        /* determine the size of the coded buffer */
719
        size_out /= osize;
720
        if (coded_bps)
721
            size_out *= coded_bps;
722

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

    
741
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
742
{
743
    AVCodecContext *dec;
744
    AVPicture *picture2;
745
    AVPicture picture_tmp;
746
    uint8_t *buf = 0;
747

    
748
    dec = ist->st->codec;
749

    
750
    /* deinterlace : must be done before any resize */
751
    if (do_deinterlace) {
752
        int size;
753

    
754
        /* create temporary picture */
755
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
756
        buf = av_malloc(size);
757
        if (!buf)
758
            return;
759

    
760
        picture2 = &picture_tmp;
761
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
762

    
763
        if(avpicture_deinterlace(picture2, picture,
764
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
765
            /* if error, do not deinterlace */
766
            fprintf(stderr, "Deinterlacing failed\n");
767
            av_free(buf);
768
            buf = NULL;
769
            picture2 = picture;
770
        }
771
    } else {
772
        picture2 = picture;
773
    }
774

    
775
    if (picture != picture2)
776
        *picture = *picture2;
777
    *bufp = buf;
778
}
779

    
780
/* we begin to correct av delay at this threshold */
781
#define AV_DELAY_MAX 0.100
782

    
783
static void do_subtitle_out(AVFormatContext *s,
784
                            AVOutputStream *ost,
785
                            AVInputStream *ist,
786
                            AVSubtitle *sub,
787
                            int64_t pts)
788
{
789
    static uint8_t *subtitle_out = NULL;
790
    int subtitle_out_max_size = 65536;
791
    int subtitle_out_size, nb, i;
792
    AVCodecContext *enc;
793
    AVPacket pkt;
794

    
795
    if (pts == AV_NOPTS_VALUE) {
796
        fprintf(stderr, "Subtitle packets must have a pts\n");
797
        if (exit_on_error)
798
            av_exit(1);
799
        return;
800
    }
801

    
802
    enc = ost->st->codec;
803

    
804
    if (!subtitle_out) {
805
        subtitle_out = av_malloc(subtitle_out_max_size);
806
    }
807

    
808
    /* Note: DVB subtitle need one packet to draw them and one other
809
       packet to clear them */
810
    /* XXX: signal it in the codec context ? */
811
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
812
        nb = 2;
813
    else
814
        nb = 1;
815

    
816
    for(i = 0; i < nb; i++) {
817
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
818
                                                    subtitle_out_max_size, sub);
819

    
820
        av_init_packet(&pkt);
821
        pkt.stream_index = ost->index;
822
        pkt.data = subtitle_out;
823
        pkt.size = subtitle_out_size;
824
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
825
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
826
            /* XXX: the pts correction is handled here. Maybe handling
827
               it in the codec would be better */
828
            if (i == 0)
829
                pkt.pts += 90 * sub->start_display_time;
830
            else
831
                pkt.pts += 90 * sub->end_display_time;
832
        }
833
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
834
    }
835
}
836

    
837
static int bit_buffer_size= 1024*256;
838
static uint8_t *bit_buffer= NULL;
839

    
840
static void do_video_out(AVFormatContext *s,
841
                         AVOutputStream *ost,
842
                         AVInputStream *ist,
843
                         AVFrame *in_picture,
844
                         int *frame_size)
845
{
846
    int nb_frames, i, ret;
847
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
848
    AVFrame picture_crop_temp, picture_pad_temp;
849
    AVCodecContext *enc, *dec;
850

    
851
    avcodec_get_frame_defaults(&picture_crop_temp);
852
    avcodec_get_frame_defaults(&picture_pad_temp);
853

    
854
    enc = ost->st->codec;
855
    dec = ist->st->codec;
856

    
857
    /* by default, we output a single frame */
858
    nb_frames = 1;
859

    
860
    *frame_size = 0;
861

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

    
888
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
889
    if (nb_frames <= 0)
890
        return;
891

    
892
    if (ost->video_crop) {
893
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
894
            fprintf(stderr, "error cropping picture\n");
895
            if (exit_on_error)
896
                av_exit(1);
897
            return;
898
        }
899
        formatted_picture = &picture_crop_temp;
900
    } else {
901
        formatted_picture = in_picture;
902
    }
903

    
904
    final_picture = formatted_picture;
905
    padding_src = formatted_picture;
906
    resampling_dst = &ost->pict_tmp;
907
    if (ost->video_pad) {
908
        final_picture = &ost->pict_tmp;
909
        if (ost->video_resample) {
910
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
911
                fprintf(stderr, "error padding picture\n");
912
                if (exit_on_error)
913
                    av_exit(1);
914
                return;
915
            }
916
            resampling_dst = &picture_pad_temp;
917
        }
918
    }
919

    
920
    if (ost->video_resample) {
921
        padding_src = NULL;
922
        final_picture = &ost->pict_tmp;
923
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
924
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
925
    }
926

    
927
    if (ost->video_pad) {
928
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
929
                enc->height, enc->width, enc->pix_fmt,
930
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
931
    }
932

    
933
    /* duplicates frame if needed */
934
    for(i=0;i<nb_frames;i++) {
935
        AVPacket pkt;
936
        av_init_packet(&pkt);
937
        pkt.stream_index= ost->index;
938

    
939
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
940
            /* raw pictures are written as AVPicture structure to
941
               avoid any copies. We support temorarily the older
942
               method. */
943
            AVFrame* old_frame = enc->coded_frame;
944
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
945
            pkt.data= (uint8_t *)final_picture;
946
            pkt.size=  sizeof(AVPicture);
947
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
948
            pkt.flags |= PKT_FLAG_KEY;
949

    
950
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
951
            enc->coded_frame = old_frame;
952
        } else {
953
            AVFrame big_picture;
954

    
955
            big_picture= *final_picture;
956
            /* better than nothing: use input picture interlaced
957
               settings */
958
            big_picture.interlaced_frame = in_picture->interlaced_frame;
959
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
960
                if(top_field_first == -1)
961
                    big_picture.top_field_first = in_picture->top_field_first;
962
                else
963
                    big_picture.top_field_first = top_field_first;
964
            }
965

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

    
986
            if(ret>0){
987
                pkt.data= bit_buffer;
988
                pkt.size= ret;
989
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
990
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
991
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
992
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
993
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
994

    
995
                if(enc->coded_frame->key_frame)
996
                    pkt.flags |= PKT_FLAG_KEY;
997
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
998
                *frame_size = ret;
999
                video_size += ret;
1000
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1001
                //        enc->frame_number-1, ret, enc->pict_type);
1002
                /* if two pass, output log */
1003
                if (ost->logfile && enc->stats_out) {
1004
                    fprintf(ost->logfile, "%s", enc->stats_out);
1005
                }
1006
            }
1007
        }
1008
        ost->sync_opts++;
1009
        ost->frame_number++;
1010
    }
1011
}
1012

    
1013
static double psnr(double d){
1014
    return -10.0*log(d)/log(10.0);
1015
}
1016

    
1017
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1018
                           int frame_size)
1019
{
1020
    AVCodecContext *enc;
1021
    int frame_number;
1022
    double ti1, bitrate, avg_bitrate;
1023

    
1024
    /* this is executed just the first time do_video_stats is called */
1025
    if (!vstats_file) {
1026
        vstats_file = fopen(vstats_filename, "w");
1027
        if (!vstats_file) {
1028
            perror("fopen");
1029
            av_exit(1);
1030
        }
1031
    }
1032

    
1033
    enc = ost->st->codec;
1034
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1035
        frame_number = ost->frame_number;
1036
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1037
        if (enc->flags&CODEC_FLAG_PSNR)
1038
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1039

    
1040
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1041
        /* compute pts value */
1042
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1043
        if (ti1 < 0.01)
1044
            ti1 = 0.01;
1045

    
1046
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1047
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1048
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1049
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1050
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1051
    }
1052
}
1053

    
1054
static void print_report(AVFormatContext **output_files,
1055
                         AVOutputStream **ost_table, int nb_ostreams,
1056
                         int is_last_report)
1057
{
1058
    char buf[1024];
1059
    AVOutputStream *ost;
1060
    AVFormatContext *oc;
1061
    int64_t total_size;
1062
    AVCodecContext *enc;
1063
    int frame_number, vid, i;
1064
    double bitrate, ti1, pts;
1065
    static int64_t last_time = -1;
1066
    static int qp_histogram[52];
1067

    
1068
    if (!is_last_report) {
1069
        int64_t cur_time;
1070
        /* display the report every 0.5 seconds */
1071
        cur_time = av_gettime();
1072
        if (last_time == -1) {
1073
            last_time = cur_time;
1074
            return;
1075
        }
1076
        if ((cur_time - last_time) < 500000)
1077
            return;
1078
        last_time = cur_time;
1079
    }
1080

    
1081

    
1082
    oc = output_files[0];
1083

    
1084
    total_size = url_fsize(oc->pb);
1085
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1086
        total_size= url_ftell(oc->pb);
1087

    
1088
    buf[0] = '\0';
1089
    ti1 = 1e10;
1090
    vid = 0;
1091
    for(i=0;i<nb_ostreams;i++) {
1092
        ost = ost_table[i];
1093
        enc = ost->st->codec;
1094
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1095
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1096
                     !ost->st->stream_copy ?
1097
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1098
        }
1099
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1100
            float t = (av_gettime()-timer_start) / 1000000.0;
1101

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

    
1148
    if (verbose || is_last_report) {
1149
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1150

    
1151
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1152
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1153
            (double)total_size / 1024, ti1, bitrate);
1154

    
1155
        if (verbose > 1)
1156
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1157
                  nb_frames_dup, nb_frames_drop);
1158

    
1159
        if (verbose >= 0)
1160
            fprintf(stderr, "%s    \r", buf);
1161

    
1162
        fflush(stderr);
1163
    }
1164

    
1165
    if (is_last_report && verbose >= 0){
1166
        int64_t raw= audio_size + video_size + extra_size;
1167
        fprintf(stderr, "\n");
1168
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1169
                video_size/1024.0,
1170
                audio_size/1024.0,
1171
                extra_size/1024.0,
1172
                100.0*(total_size - raw)/raw
1173
        );
1174
    }
1175
}
1176

    
1177
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1178
static int output_packet(AVInputStream *ist, int ist_index,
1179
                         AVOutputStream **ost_table, int nb_ostreams,
1180
                         const AVPacket *pkt)
1181
{
1182
    AVFormatContext *os;
1183
    AVOutputStream *ost;
1184
    int ret, i;
1185
    uint8_t *data_buf;
1186
    int data_size, got_picture;
1187
    AVFrame picture;
1188
    void *buffer_to_free;
1189
    static unsigned int samples_size= 0;
1190
    AVSubtitle subtitle, *subtitle_to_free;
1191
    int got_subtitle;
1192
    AVPacket avpkt;
1193

    
1194
    if(ist->next_pts == AV_NOPTS_VALUE)
1195
        ist->next_pts= ist->pts;
1196

    
1197
    if (pkt == NULL) {
1198
        /* EOF handling */
1199
        av_init_packet(&avpkt);
1200
        avpkt.data = NULL;
1201
        avpkt.size = 0;
1202
        goto handle_eof;
1203
    } else {
1204
        avpkt = *pkt;
1205
    }
1206

    
1207
    if(pkt->dts != AV_NOPTS_VALUE)
1208
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1209

    
1210
    //while we have more to decode or while the decoder did output something on EOF
1211
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1212
    handle_eof:
1213
        ist->pts= ist->next_pts;
1214

    
1215
        if(avpkt.size && avpkt.size != pkt->size && verbose>0)
1216
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1217

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

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

    
1306
        buffer_to_free = NULL;
1307
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1308
            pre_process_video_frame(ist, (AVPicture *)&picture,
1309
                                    &buffer_to_free);
1310
        }
1311

    
1312
        // preprocess audio (volume)
1313
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1314
            if (audio_volume != 256) {
1315
                short *volp;
1316
                volp = samples;
1317
                for(i=0;i<(data_size / sizeof(short));i++) {
1318
                    int v = ((*volp) * audio_volume + 128) >> 8;
1319
                    if (v < -32768) v = -32768;
1320
                    if (v >  32767) v = 32767;
1321
                    *volp++ = v;
1322
                }
1323
            }
1324
        }
1325

    
1326
        /* frame rate emulation */
1327
        if (rate_emu) {
1328
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1329
            int64_t now = av_gettime() - ist->start;
1330
            if (pts > now)
1331
                usleep(pts - now);
1332
        }
1333

    
1334
        /* if output time reached then transcode raw format,
1335
           encode packets and output them */
1336
        if (start_time == 0 || ist->pts >= start_time)
1337
            for(i=0;i<nb_ostreams;i++) {
1338
                int frame_size;
1339

    
1340
                ost = ost_table[i];
1341
                if (ost->source_index == ist_index) {
1342
                    os = output_files[ost->file_index];
1343

    
1344
#if 0
1345
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1346
                           (double)pkt->pts / AV_TIME_BASE,
1347
                           ((double)ist->pts / AV_TIME_BASE) -
1348
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1349
#endif
1350
                    /* set the input output pts pairs */
1351
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1352

    
1353
                    if (ost->encoding_needed) {
1354
                        switch(ost->st->codec->codec_type) {
1355
                        case CODEC_TYPE_AUDIO:
1356
                            do_audio_out(os, ost, ist, data_buf, data_size);
1357
                            break;
1358
                        case CODEC_TYPE_VIDEO:
1359
                            do_video_out(os, ost, ist, &picture, &frame_size);
1360
                            if (vstats_filename && frame_size)
1361
                                do_video_stats(os, ost, frame_size);
1362
                            break;
1363
                        case CODEC_TYPE_SUBTITLE:
1364
                            do_subtitle_out(os, ost, ist, &subtitle,
1365
                                            pkt->pts);
1366
                            break;
1367
                        default:
1368
                            abort();
1369
                        }
1370
                    } else {
1371
                        AVFrame avframe; //FIXME/XXX remove this
1372
                        AVPacket opkt;
1373
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1374

    
1375
                        av_init_packet(&opkt);
1376

    
1377
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1378
                            continue;
1379

    
1380
                        /* no reencoding needed : output the packet directly */
1381
                        /* force the input stream PTS */
1382

    
1383
                        avcodec_get_frame_defaults(&avframe);
1384
                        ost->st->codec->coded_frame= &avframe;
1385
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1386

    
1387
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1388
                            audio_size += data_size;
1389
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1390
                            video_size += data_size;
1391
                            ost->sync_opts++;
1392
                        }
1393

    
1394
                        opkt.stream_index= ost->index;
1395
                        if(pkt->pts != AV_NOPTS_VALUE)
1396
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1397
                        else
1398
                            opkt.pts= AV_NOPTS_VALUE;
1399

    
1400
                        if (pkt->dts == AV_NOPTS_VALUE)
1401
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1402
                        else
1403
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1404
                        opkt.dts -= ost_tb_start_time;
1405

    
1406
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1407
                        opkt.flags= pkt->flags;
1408

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

    
1413
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1414
                        ost->st->codec->frame_number++;
1415
                        ost->frame_number++;
1416
                        av_free_packet(&opkt);
1417
                    }
1418
                }
1419
            }
1420
        av_free(buffer_to_free);
1421
        /* XXX: allocate the subtitles in the codec ? */
1422
        if (subtitle_to_free) {
1423
            if (subtitle_to_free->rects != NULL) {
1424
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1425
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1426
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1427
                    av_freep(&subtitle_to_free->rects[i]);
1428
                }
1429
                av_freep(&subtitle_to_free->rects);
1430
            }
1431
            subtitle_to_free->num_rects = 0;
1432
            subtitle_to_free = NULL;
1433
        }
1434
    }
1435
 discard_packet:
1436
    if (pkt == NULL) {
1437
        /* EOF handling */
1438

    
1439
        for(i=0;i<nb_ostreams;i++) {
1440
            ost = ost_table[i];
1441
            if (ost->source_index == ist_index) {
1442
                AVCodecContext *enc= ost->st->codec;
1443
                os = output_files[ost->file_index];
1444

    
1445
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1446
                    continue;
1447
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1448
                    continue;
1449

    
1450
                if (ost->encoding_needed) {
1451
                    for(;;) {
1452
                        AVPacket pkt;
1453
                        int fifo_bytes;
1454
                        av_init_packet(&pkt);
1455
                        pkt.stream_index= ost->index;
1456

    
1457
                        switch(ost->st->codec->codec_type) {
1458
                        case CODEC_TYPE_AUDIO:
1459
                            fifo_bytes = av_fifo_size(ost->fifo);
1460
                            ret = 0;
1461
                            /* encode any samples remaining in fifo */
1462
                            if (fifo_bytes > 0) {
1463
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1464
                                int fs_tmp = enc->frame_size;
1465

    
1466
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1467
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1468
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1469
                                } else { /* pad */
1470
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1471
                                    if (samples_size < frame_bytes)
1472
                                        av_exit(1);
1473
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1474
                                }
1475

    
1476
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1477
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1478
                                                          ost->st->time_base.num, enc->sample_rate);
1479
                                enc->frame_size = fs_tmp;
1480
                            }
1481
                            if(ret <= 0) {
1482
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1483
                            }
1484
                            if (ret < 0) {
1485
                                fprintf(stderr, "Audio encoding failed\n");
1486
                                av_exit(1);
1487
                            }
1488
                            audio_size += ret;
1489
                            pkt.flags |= PKT_FLAG_KEY;
1490
                            break;
1491
                        case CODEC_TYPE_VIDEO:
1492
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1493
                            if (ret < 0) {
1494
                                fprintf(stderr, "Video encoding failed\n");
1495
                                av_exit(1);
1496
                            }
1497
                            video_size += ret;
1498
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1499
                                pkt.flags |= PKT_FLAG_KEY;
1500
                            if (ost->logfile && enc->stats_out) {
1501
                                fprintf(ost->logfile, "%s", enc->stats_out);
1502
                            }
1503
                            break;
1504
                        default:
1505
                            ret=-1;
1506
                        }
1507

    
1508
                        if(ret<=0)
1509
                            break;
1510
                        pkt.data= bit_buffer;
1511
                        pkt.size= ret;
1512
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1513
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1514
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1515
                    }
1516
                }
1517
            }
1518
        }
1519
    }
1520

    
1521
    return 0;
1522
 fail_decode:
1523
    return -1;
1524
}
1525

    
1526
static void print_sdp(AVFormatContext **avc, int n)
1527
{
1528
    char sdp[2048];
1529

    
1530
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1531
    printf("SDP:\n%s\n", sdp);
1532
    fflush(stdout);
1533
}
1534

    
1535
static int stream_index_from_inputs(AVFormatContext **input_files,
1536
                                    int nb_input_files,
1537
                                    AVInputFile *file_table,
1538
                                    AVInputStream **ist_table,
1539
                                    enum CodecType type,
1540
                                    int programid)
1541
{
1542
    int p, q, z;
1543
    for(z=0; z<nb_input_files; z++) {
1544
        AVFormatContext *ic = input_files[z];
1545
        for(p=0; p<ic->nb_programs; p++) {
1546
            AVProgram *program = ic->programs[p];
1547
            if(program->id != programid)
1548
                continue;
1549
            for(q=0; q<program->nb_stream_indexes; q++) {
1550
                int sidx = program->stream_index[q];
1551
                int ris = file_table[z].ist_index + sidx;
1552
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1553
                    return ris;
1554
            }
1555
        }
1556
    }
1557

    
1558
    return -1;
1559
}
1560

    
1561
/*
1562
 * The following code is the main loop of the file converter
1563
 */
1564
static int av_encode(AVFormatContext **output_files,
1565
                     int nb_output_files,
1566
                     AVFormatContext **input_files,
1567
                     int nb_input_files,
1568
                     AVStreamMap *stream_maps, int nb_stream_maps)
1569
{
1570
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1571
    AVFormatContext *is, *os;
1572
    AVCodecContext *codec, *icodec;
1573
    AVOutputStream *ost, **ost_table = NULL;
1574
    AVInputStream *ist, **ist_table = NULL;
1575
    AVInputFile *file_table;
1576
    char error[1024];
1577
    int key;
1578
    int want_sdp = 1;
1579
    uint8_t no_packet[MAX_FILES]={0};
1580
    int no_packet_count=0;
1581

    
1582
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1583
    if (!file_table)
1584
        goto fail;
1585

    
1586
    /* input stream init */
1587
    j = 0;
1588
    for(i=0;i<nb_input_files;i++) {
1589
        is = input_files[i];
1590
        file_table[i].ist_index = j;
1591
        file_table[i].nb_streams = is->nb_streams;
1592
        j += is->nb_streams;
1593
    }
1594
    nb_istreams = j;
1595

    
1596
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1597
    if (!ist_table)
1598
        goto fail;
1599

    
1600
    for(i=0;i<nb_istreams;i++) {
1601
        ist = av_mallocz(sizeof(AVInputStream));
1602
        if (!ist)
1603
            goto fail;
1604
        ist_table[i] = ist;
1605
    }
1606
    j = 0;
1607
    for(i=0;i<nb_input_files;i++) {
1608
        is = input_files[i];
1609
        for(k=0;k<is->nb_streams;k++) {
1610
            ist = ist_table[j++];
1611
            ist->st = is->streams[k];
1612
            ist->file_index = i;
1613
            ist->index = k;
1614
            ist->discard = 1; /* the stream is discarded by default
1615
                                 (changed later) */
1616

    
1617
            if (rate_emu) {
1618
                ist->start = av_gettime();
1619
            }
1620
        }
1621
    }
1622

    
1623
    /* output stream init */
1624
    nb_ostreams = 0;
1625
    for(i=0;i<nb_output_files;i++) {
1626
        os = output_files[i];
1627
        if (!os->nb_streams) {
1628
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1629
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1630
            av_exit(1);
1631
        }
1632
        nb_ostreams += os->nb_streams;
1633
    }
1634
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1635
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1636
        av_exit(1);
1637
    }
1638

    
1639
    /* Sanity check the mapping args -- do the input files & streams exist? */
1640
    for(i=0;i<nb_stream_maps;i++) {
1641
        int fi = stream_maps[i].file_index;
1642
        int si = stream_maps[i].stream_index;
1643

    
1644
        if (fi < 0 || fi > nb_input_files - 1 ||
1645
            si < 0 || si > file_table[fi].nb_streams - 1) {
1646
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1647
            av_exit(1);
1648
        }
1649
        fi = stream_maps[i].sync_file_index;
1650
        si = stream_maps[i].sync_stream_index;
1651
        if (fi < 0 || fi > nb_input_files - 1 ||
1652
            si < 0 || si > file_table[fi].nb_streams - 1) {
1653
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1654
            av_exit(1);
1655
        }
1656
    }
1657

    
1658
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1659
    if (!ost_table)
1660
        goto fail;
1661
    for(i=0;i<nb_ostreams;i++) {
1662
        ost = av_mallocz(sizeof(AVOutputStream));
1663
        if (!ost)
1664
            goto fail;
1665
        ost_table[i] = ost;
1666
    }
1667

    
1668
    n = 0;
1669
    for(k=0;k<nb_output_files;k++) {
1670
        os = output_files[k];
1671
        for(i=0;i<os->nb_streams;i++,n++) {
1672
            int found;
1673
            ost = ost_table[n];
1674
            ost->file_index = k;
1675
            ost->index = i;
1676
            ost->st = os->streams[i];
1677
            if (nb_stream_maps > 0) {
1678
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1679
                    stream_maps[n].stream_index;
1680

    
1681
                /* Sanity check that the stream types match */
1682
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1683
                    int i= ost->file_index;
1684
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1685
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1686
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1687
                        ost->file_index, ost->index);
1688
                    av_exit(1);
1689
                }
1690

    
1691
            } else {
1692
                if(opt_programid) {
1693
                    found = 0;
1694
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1695
                    if(j != -1) {
1696
                        ost->source_index = j;
1697
                        found = 1;
1698
                    }
1699
                } else {
1700
                    /* get corresponding input stream index : we select the first one with the right type */
1701
                    found = 0;
1702
                    for(j=0;j<nb_istreams;j++) {
1703
                        ist = ist_table[j];
1704
                        if (ist->discard &&
1705
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1706
                            ost->source_index = j;
1707
                            found = 1;
1708
                            break;
1709
                        }
1710
                    }
1711
                }
1712

    
1713
                if (!found) {
1714
                    if(! opt_programid) {
1715
                        /* try again and reuse existing stream */
1716
                        for(j=0;j<nb_istreams;j++) {
1717
                            ist = ist_table[j];
1718
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1719
                                ost->source_index = j;
1720
                                found = 1;
1721
                            }
1722
                        }
1723
                    }
1724
                    if (!found) {
1725
                        int i= ost->file_index;
1726
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1727
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1728
                                ost->file_index, ost->index);
1729
                        av_exit(1);
1730
                    }
1731
                }
1732
            }
1733
            ist = ist_table[ost->source_index];
1734
            ist->discard = 0;
1735
            ost->sync_ist = (nb_stream_maps > 0) ?
1736
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1737
                         stream_maps[n].sync_stream_index] : ist;
1738
        }
1739
    }
1740

    
1741
    /* for each output stream, we compute the right encoding parameters */
1742
    for(i=0;i<nb_ostreams;i++) {
1743
        AVMetadataTag *lang;
1744
        ost = ost_table[i];
1745
        os = output_files[ost->file_index];
1746
        ist = ist_table[ost->source_index];
1747

    
1748
        codec = ost->st->codec;
1749
        icodec = ist->st->codec;
1750

    
1751
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1752
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1753
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1754

    
1755
        ost->st->disposition = ist->st->disposition;
1756
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1757
        codec->chroma_sample_location = icodec->chroma_sample_location;
1758

    
1759
        if (ost->st->stream_copy) {
1760
            /* if stream_copy is selected, no need to decode or encode */
1761
            codec->codec_id = icodec->codec_id;
1762
            codec->codec_type = icodec->codec_type;
1763

    
1764
            if(!codec->codec_tag){
1765
                if(   !os->oformat->codec_tag
1766
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1767
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1768
                    codec->codec_tag = icodec->codec_tag;
1769
            }
1770

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

    
1888
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1889
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1890
                         i);
1891
                if (codec->flags & CODEC_FLAG_PASS1) {
1892
                    f = fopen(logfilename, "w");
1893
                    if (!f) {
1894
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1895
                        av_exit(1);
1896
                    }
1897
                    ost->logfile = f;
1898
                } else {
1899
                    /* read the log file */
1900
                    f = fopen(logfilename, "r");
1901
                    if (!f) {
1902
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1903
                        av_exit(1);
1904
                    }
1905
                    fseek(f, 0, SEEK_END);
1906
                    size = ftell(f);
1907
                    fseek(f, 0, SEEK_SET);
1908
                    logbuffer = av_malloc(size + 1);
1909
                    if (!logbuffer) {
1910
                        fprintf(stderr, "Could not allocate log buffer\n");
1911
                        av_exit(1);
1912
                    }
1913
                    size = fread(logbuffer, 1, size, f);
1914
                    fclose(f);
1915
                    logbuffer[size] = '\0';
1916
                    codec->stats_in = logbuffer;
1917
                }
1918
            }
1919
        }
1920
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1921
            int size= codec->width * codec->height;
1922
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1923
        }
1924
    }
1925

    
1926
    if (!bit_buffer)
1927
        bit_buffer = av_malloc(bit_buffer_size);
1928
    if (!bit_buffer) {
1929
        ret = AVERROR(ENOMEM);
1930
        goto fail;
1931
    }
1932

    
1933
    /* open each encoder */
1934
    for(i=0;i<nb_ostreams;i++) {
1935
        ost = ost_table[i];
1936
        if (ost->encoding_needed) {
1937
            AVCodec *codec = output_codecs[i];
1938
            if (!codec)
1939
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
1940
            if (!codec) {
1941
                snprintf(error, sizeof(error), "Unsupported codec for output stream #%d.%d",
1942
                        ost->file_index, ost->index);
1943
                ret = AVERROR(EINVAL);
1944
                goto dump_format;
1945
            }
1946
            if (avcodec_open(ost->st->codec, codec) < 0) {
1947
                snprintf(error, sizeof(error), "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1948
                        ost->file_index, ost->index);
1949
                ret = AVERROR(EINVAL);
1950
                goto dump_format;
1951
            }
1952
            extra_size += ost->st->codec->extradata_size;
1953
        }
1954
    }
1955

    
1956
    /* open each decoder */
1957
    for(i=0;i<nb_istreams;i++) {
1958
        ist = ist_table[i];
1959
        if (ist->decoding_needed) {
1960
            AVCodec *codec = input_codecs[i];
1961
            if (!codec)
1962
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
1963
            if (!codec) {
1964
                snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
1965
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1966
                ret = AVERROR(EINVAL);
1967
                goto dump_format;
1968
            }
1969
            if (avcodec_open(ist->st->codec, codec) < 0) {
1970
                snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
1971
                        ist->file_index, ist->index);
1972
                ret = AVERROR(EINVAL);
1973
                goto dump_format;
1974
            }
1975
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1976
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1977
        }
1978
    }
1979

    
1980
    /* init pts */
1981
    for(i=0;i<nb_istreams;i++) {
1982
        ist = ist_table[i];
1983
        ist->pts = 0;
1984
        ist->next_pts = AV_NOPTS_VALUE;
1985
        ist->is_start = 1;
1986
    }
1987

    
1988
    /* set meta data information from input file if required */
1989
    for (i=0;i<nb_meta_data_maps;i++) {
1990
        AVFormatContext *out_file;
1991
        AVFormatContext *in_file;
1992
        AVMetadataTag *mtag;
1993

    
1994
        int out_file_index = meta_data_maps[i].out_file;
1995
        int in_file_index = meta_data_maps[i].in_file;
1996
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1997
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
1998
                     out_file_index, out_file_index, in_file_index);
1999
            ret = AVERROR(EINVAL);
2000
            goto dump_format;
2001
        }
2002
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2003
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2004
                     in_file_index, out_file_index, in_file_index);
2005
            ret = AVERROR(EINVAL);
2006
            goto dump_format;
2007
        }
2008

    
2009
        out_file = output_files[out_file_index];
2010
        in_file = input_files[in_file_index];
2011

    
2012

    
2013
        mtag=NULL;
2014
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2015
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2016
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2017
                                    in_file->iformat->metadata_conv);
2018
    }
2019

    
2020
    /* open files and write file headers */
2021
    for(i=0;i<nb_output_files;i++) {
2022
        os = output_files[i];
2023
        if (av_write_header(os) < 0) {
2024
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2025
            ret = AVERROR(EINVAL);
2026
            goto dump_format;
2027
        }
2028
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2029
            want_sdp = 0;
2030
        }
2031
    }
2032

    
2033
 dump_format:
2034
    /* dump the file output parameters - cannot be done before in case
2035
       of stream copy */
2036
    for(i=0;i<nb_output_files;i++) {
2037
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2038
    }
2039

    
2040
    /* dump the stream mapping */
2041
    if (verbose >= 0) {
2042
        fprintf(stderr, "Stream mapping:\n");
2043
        for(i=0;i<nb_ostreams;i++) {
2044
            ost = ost_table[i];
2045
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2046
                    ist_table[ost->source_index]->file_index,
2047
                    ist_table[ost->source_index]->index,
2048
                    ost->file_index,
2049
                    ost->index);
2050
            if (ost->sync_ist != ist_table[ost->source_index])
2051
                fprintf(stderr, " [sync #%d.%d]",
2052
                        ost->sync_ist->file_index,
2053
                        ost->sync_ist->index);
2054
            fprintf(stderr, "\n");
2055
        }
2056
    }
2057

    
2058
    if (ret) {
2059
        fprintf(stderr, "%s\n", error);
2060
        goto fail;
2061
    }
2062

    
2063
    if (want_sdp) {
2064
        print_sdp(output_files, nb_output_files);
2065
    }
2066

    
2067
    if (!using_stdin && verbose >= 0) {
2068
        fprintf(stderr, "Press [q] to stop encoding\n");
2069
        url_set_interrupt_cb(decode_interrupt_cb);
2070
    }
2071
    term_init();
2072

    
2073
    timer_start = av_gettime();
2074

    
2075
    for(; received_sigterm == 0;) {
2076
        int file_index, ist_index;
2077
        AVPacket pkt;
2078
        double ipts_min;
2079
        double opts_min;
2080

    
2081
    redo:
2082
        ipts_min= 1e100;
2083
        opts_min= 1e100;
2084
        /* if 'q' pressed, exits */
2085
        if (!using_stdin) {
2086
            if (q_pressed)
2087
                break;
2088
            /* read_key() returns 0 on EOF */
2089
            key = read_key();
2090
            if (key == 'q')
2091
                break;
2092
        }
2093

    
2094
        /* select the stream that we must read now by looking at the
2095
           smallest output pts */
2096
        file_index = -1;
2097
        for(i=0;i<nb_ostreams;i++) {
2098
            double ipts, opts;
2099
            ost = ost_table[i];
2100
            os = output_files[ost->file_index];
2101
            ist = ist_table[ost->source_index];
2102
            if(no_packet[ist->file_index])
2103
                continue;
2104
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2105
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2106
            else
2107
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2108
            ipts = (double)ist->pts;
2109
            if (!file_table[ist->file_index].eof_reached){
2110
                if(ipts < ipts_min) {
2111
                    ipts_min = ipts;
2112
                    if(input_sync ) file_index = ist->file_index;
2113
                }
2114
                if(opts < opts_min) {
2115
                    opts_min = opts;
2116
                    if(!input_sync) file_index = ist->file_index;
2117
                }
2118
            }
2119
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2120
                file_index= -1;
2121
                break;
2122
            }
2123
        }
2124
        /* if none, if is finished */
2125
        if (file_index < 0) {
2126
            if(no_packet_count){
2127
                no_packet_count=0;
2128
                memset(no_packet, 0, sizeof(no_packet));
2129
                usleep(10000);
2130
                continue;
2131
            }
2132
            break;
2133
        }
2134

    
2135
        /* finish if recording time exhausted */
2136
        if (opts_min >= (recording_time / 1000000.0))
2137
            break;
2138

    
2139
        /* finish if limit size exhausted */
2140
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2141
            break;
2142

    
2143
        /* read a frame from it and output it in the fifo */
2144
        is = input_files[file_index];
2145
        ret= av_read_frame(is, &pkt);
2146
        if(ret == AVERROR(EAGAIN)){
2147
            no_packet[file_index]=1;
2148
            no_packet_count++;
2149
            continue;
2150
        }
2151
        if (ret < 0) {
2152
            file_table[file_index].eof_reached = 1;
2153
            if (opt_shortest)
2154
                break;
2155
            else
2156
                continue;
2157
        }
2158

    
2159
        no_packet_count=0;
2160
        memset(no_packet, 0, sizeof(no_packet));
2161

    
2162
        if (do_pkt_dump) {
2163
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2164
        }
2165
        /* the following test is needed in case new streams appear
2166
           dynamically in stream : we ignore them */
2167
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2168
            goto discard_packet;
2169
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2170
        ist = ist_table[ist_index];
2171
        if (ist->discard)
2172
            goto discard_packet;
2173

    
2174
        if (pkt.dts != AV_NOPTS_VALUE)
2175
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2176
        if (pkt.pts != AV_NOPTS_VALUE)
2177
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2178

    
2179
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2180
            if(pkt.pts != AV_NOPTS_VALUE)
2181
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2182
            if(pkt.dts != AV_NOPTS_VALUE)
2183
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2184
        }
2185

    
2186
//        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);
2187
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2188
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2189
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2190
            int64_t delta= pkt_dts - ist->next_pts;
2191
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2192
                input_files_ts_offset[ist->file_index]-= delta;
2193
                if (verbose > 2)
2194
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2195
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2196
                if(pkt.pts != AV_NOPTS_VALUE)
2197
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2198
            }
2199
        }
2200

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

    
2204
            if (verbose >= 0)
2205
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2206
                        ist->file_index, ist->index);
2207
            if (exit_on_error)
2208
                av_exit(1);
2209
            av_free_packet(&pkt);
2210
            goto redo;
2211
        }
2212

    
2213
    discard_packet:
2214
        av_free_packet(&pkt);
2215

    
2216
        /* dump report by using the output first video and audio streams */
2217
        print_report(output_files, ost_table, nb_ostreams, 0);
2218
    }
2219

    
2220
    /* at the end of stream, we must flush the decoder buffers */
2221
    for(i=0;i<nb_istreams;i++) {
2222
        ist = ist_table[i];
2223
        if (ist->decoding_needed) {
2224
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2225
        }
2226
    }
2227

    
2228
    term_exit();
2229

    
2230
    /* write the trailer if needed and close file */
2231
    for(i=0;i<nb_output_files;i++) {
2232
        os = output_files[i];
2233
        av_write_trailer(os);
2234
    }
2235

    
2236
    /* dump report by using the first video and audio streams */
2237
    print_report(output_files, ost_table, nb_ostreams, 1);
2238

    
2239
    /* close each encoder */
2240
    for(i=0;i<nb_ostreams;i++) {
2241
        ost = ost_table[i];
2242
        if (ost->encoding_needed) {
2243
            av_freep(&ost->st->codec->stats_in);
2244
            avcodec_close(ost->st->codec);
2245
        }
2246
    }
2247

    
2248
    /* close each decoder */
2249
    for(i=0;i<nb_istreams;i++) {
2250
        ist = ist_table[i];
2251
        if (ist->decoding_needed) {
2252
            avcodec_close(ist->st->codec);
2253
        }
2254
    }
2255

    
2256
    /* finished ! */
2257
    ret = 0;
2258

    
2259
 fail:
2260
    av_freep(&bit_buffer);
2261
    av_free(file_table);
2262

    
2263
    if (ist_table) {
2264
        for(i=0;i<nb_istreams;i++) {
2265
            ist = ist_table[i];
2266
            av_free(ist);
2267
        }
2268
        av_free(ist_table);
2269
    }
2270
    if (ost_table) {
2271
        for(i=0;i<nb_ostreams;i++) {
2272
            ost = ost_table[i];
2273
            if (ost) {
2274
                if (ost->logfile) {
2275
                    fclose(ost->logfile);
2276
                    ost->logfile = NULL;
2277
                }
2278
                av_fifo_free(ost->fifo); /* works even if fifo is not
2279
                                             initialized but set to zero */
2280
                av_free(ost->pict_tmp.data[0]);
2281
                if (ost->video_resample)
2282
                    sws_freeContext(ost->img_resample_ctx);
2283
                if (ost->resample)
2284
                    audio_resample_close(ost->resample);
2285
                if (ost->reformat_ctx)
2286
                    av_audio_convert_free(ost->reformat_ctx);
2287
                av_free(ost);
2288
            }
2289
        }
2290
        av_free(ost_table);
2291
    }
2292
    return ret;
2293
}
2294

    
2295
#if 0
2296
int file_read(const char *filename)
2297
{
2298
    URLContext *h;
2299
    unsigned char buffer[1024];
2300
    int len, i;
2301

2302
    if (url_open(&h, filename, O_RDONLY) < 0) {
2303
        printf("could not open '%s'\n", filename);
2304
        return -1;
2305
    }
2306
    for(;;) {
2307
        len = url_read(h, buffer, sizeof(buffer));
2308
        if (len <= 0)
2309
            break;
2310
        for(i=0;i<len;i++) putchar(buffer[i]);
2311
    }
2312
    url_close(h);
2313
    return 0;
2314
}
2315
#endif
2316

    
2317
static void opt_format(const char *arg)
2318
{
2319
    /* compatibility stuff for pgmyuv */
2320
    if (!strcmp(arg, "pgmyuv")) {
2321
        pgmyuv_compatibility_hack=1;
2322
//        opt_image_format(arg);
2323
        arg = "image2";
2324
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2325
    }
2326

    
2327
    file_iformat = av_find_input_format(arg);
2328
    file_oformat = guess_format(arg, NULL, NULL);
2329
    if (!file_iformat && !file_oformat) {
2330
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2331
        av_exit(1);
2332
    }
2333
}
2334

    
2335
static void opt_video_rc_override_string(const char *arg)
2336
{
2337
    video_rc_override_string = arg;
2338
}
2339

    
2340
static int opt_me_threshold(const char *opt, const char *arg)
2341
{
2342
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2343
    return 0;
2344
}
2345

    
2346
static int opt_loglevel(const char *opt, const char *arg)
2347
{
2348
    int level = parse_number_or_die(opt, arg, OPT_INT, INT_MIN, INT_MAX);
2349
    av_log_set_level(level);
2350
    return 0;
2351
}
2352

    
2353
static int opt_verbose(const char *opt, const char *arg)
2354
{
2355
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2356
    return 0;
2357
}
2358

    
2359
static int opt_frame_rate(const char *opt, const char *arg)
2360
{
2361
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2362
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2363
        av_exit(1);
2364
    }
2365
    return 0;
2366
}
2367

    
2368
static int opt_bitrate(const char *opt, const char *arg)
2369
{
2370
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2371

    
2372
    opt_default(opt, arg);
2373

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

    
2377
    return 0;
2378
}
2379

    
2380
static void opt_frame_crop_top(const char *arg)
2381
{
2382
    frame_topBand = atoi(arg);
2383
    if (frame_topBand < 0) {
2384
        fprintf(stderr, "Incorrect top crop size\n");
2385
        av_exit(1);
2386
    }
2387
    if ((frame_topBand) >= frame_height){
2388
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2389
        av_exit(1);
2390
    }
2391
    frame_height -= frame_topBand;
2392
}
2393

    
2394
static void opt_frame_crop_bottom(const char *arg)
2395
{
2396
    frame_bottomBand = atoi(arg);
2397
    if (frame_bottomBand < 0) {
2398
        fprintf(stderr, "Incorrect bottom crop size\n");
2399
        av_exit(1);
2400
    }
2401
    if ((frame_bottomBand) >= frame_height){
2402
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2403
        av_exit(1);
2404
    }
2405
    frame_height -= frame_bottomBand;
2406
}
2407

    
2408
static void opt_frame_crop_left(const char *arg)
2409
{
2410
    frame_leftBand = atoi(arg);
2411
    if (frame_leftBand < 0) {
2412
        fprintf(stderr, "Incorrect left crop size\n");
2413
        av_exit(1);
2414
    }
2415
    if ((frame_leftBand) >= frame_width){
2416
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2417
        av_exit(1);
2418
    }
2419
    frame_width -= frame_leftBand;
2420
}
2421

    
2422
static void opt_frame_crop_right(const char *arg)
2423
{
2424
    frame_rightBand = atoi(arg);
2425
    if (frame_rightBand < 0) {
2426
        fprintf(stderr, "Incorrect right crop size\n");
2427
        av_exit(1);
2428
    }
2429
    if ((frame_rightBand) >= frame_width){
2430
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2431
        av_exit(1);
2432
    }
2433
    frame_width -= frame_rightBand;
2434
}
2435

    
2436
static void opt_frame_size(const char *arg)
2437
{
2438
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2439
        fprintf(stderr, "Incorrect frame size\n");
2440
        av_exit(1);
2441
    }
2442
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2443
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2444
        av_exit(1);
2445
    }
2446
}
2447

    
2448
static void opt_pad_color(const char *arg) {
2449
    /* Input is expected to be six hex digits similar to
2450
       how colors are expressed in html tags (but without the #) */
2451
    int rgb = strtol(arg, NULL, 16);
2452
    int r,g,b;
2453

    
2454
    r = (rgb >> 16);
2455
    g = ((rgb >> 8) & 255);
2456
    b = (rgb & 255);
2457

    
2458
    padcolor[0] = RGB_TO_Y(r,g,b);
2459
    padcolor[1] = RGB_TO_U(r,g,b,0);
2460
    padcolor[2] = RGB_TO_V(r,g,b,0);
2461
}
2462

    
2463
static void opt_frame_pad_top(const char *arg)
2464
{
2465
    frame_padtop = atoi(arg);
2466
    if (frame_padtop < 0) {
2467
        fprintf(stderr, "Incorrect top pad size\n");
2468
        av_exit(1);
2469
    }
2470
}
2471

    
2472
static void opt_frame_pad_bottom(const char *arg)
2473
{
2474
    frame_padbottom = atoi(arg);
2475
    if (frame_padbottom < 0) {
2476
        fprintf(stderr, "Incorrect bottom pad size\n");
2477
        av_exit(1);
2478
    }
2479
}
2480

    
2481

    
2482
static void opt_frame_pad_left(const char *arg)
2483
{
2484
    frame_padleft = atoi(arg);
2485
    if (frame_padleft < 0) {
2486
        fprintf(stderr, "Incorrect left pad size\n");
2487
        av_exit(1);
2488
    }
2489
}
2490

    
2491

    
2492
static void opt_frame_pad_right(const char *arg)
2493
{
2494
    frame_padright = atoi(arg);
2495
    if (frame_padright < 0) {
2496
        fprintf(stderr, "Incorrect right pad size\n");
2497
        av_exit(1);
2498
    }
2499
}
2500

    
2501
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2502
{
2503
    int i;
2504
    char fmt_str[128];
2505
    for (i=-1; i < nb_fmts; i++) {
2506
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2507
        fprintf(stdout, "%s\n", fmt_str);
2508
    }
2509
}
2510

    
2511
static void opt_frame_pix_fmt(const char *arg)
2512
{
2513
    if (strcmp(arg, "list")) {
2514
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2515
        if (frame_pix_fmt == PIX_FMT_NONE) {
2516
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2517
            av_exit(1);
2518
        }
2519
    } else {
2520
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2521
        av_exit(0);
2522
    }
2523
}
2524

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

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

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

    
2549
static int opt_metadata(const char *opt, const char *arg)
2550
{
2551
    char *mid= strchr(arg, '=');
2552

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

    
2559
    metadata_count++;
2560
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2561
    metadata[metadata_count-1].key  = av_strdup(arg);
2562
    metadata[metadata_count-1].value= av_strdup(mid);
2563

    
2564
    return 0;
2565
}
2566

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

    
2577
static void opt_top_field_first(const char *arg)
2578
{
2579
    top_field_first= atoi(arg);
2580
}
2581

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

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

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

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

    
2614
static void opt_video_channel(const char *arg)
2615
{
2616
    video_channel = strtol(arg, NULL, 0);
2617
}
2618

    
2619
static void opt_video_standard(const char *arg)
2620
{
2621
    video_standard = av_strdup(arg);
2622
}
2623

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

    
2635
static void opt_audio_codec(const char *arg)
2636
{
2637
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2638
}
2639

    
2640
static void opt_audio_tag(const char *arg)
2641
{
2642
    char *tail;
2643
    audio_codec_tag= strtol(arg, &tail, 0);
2644

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

    
2649
static void opt_video_tag(const char *arg)
2650
{
2651
    char *tail;
2652
    video_codec_tag= strtol(arg, &tail, 0);
2653

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

    
2658
static void opt_video_codec(const char *arg)
2659
{
2660
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2661
}
2662

    
2663
static void opt_subtitle_codec(const char *arg)
2664
{
2665
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2666
}
2667

    
2668
static void opt_subtitle_tag(const char *arg)
2669
{
2670
    char *tail;
2671
    subtitle_codec_tag= strtol(arg, &tail, 0);
2672

    
2673
    if(!tail || *tail)
2674
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2675
}
2676

    
2677
static void opt_map(const char *arg)
2678
{
2679
    AVStreamMap *m;
2680
    char *p;
2681

    
2682
    m = &stream_maps[nb_stream_maps++];
2683

    
2684
    m->file_index = strtol(arg, &p, 0);
2685
    if (*p)
2686
        p++;
2687

    
2688
    m->stream_index = strtol(p, &p, 0);
2689
    if (*p) {
2690
        p++;
2691
        m->sync_file_index = strtol(p, &p, 0);
2692
        if (*p)
2693
            p++;
2694
        m->sync_stream_index = strtol(p, &p, 0);
2695
    } else {
2696
        m->sync_file_index = m->file_index;
2697
        m->sync_stream_index = m->stream_index;
2698
    }
2699
}
2700

    
2701
static void opt_map_meta_data(const char *arg)
2702
{
2703
    AVMetaDataMap *m;
2704
    char *p;
2705

    
2706
    m = &meta_data_maps[nb_meta_data_maps++];
2707

    
2708
    m->out_file = strtol(arg, &p, 0);
2709
    if (*p)
2710
        p++;
2711

    
2712
    m->in_file = strtol(p, &p, 0);
2713
}
2714

    
2715
static void opt_input_ts_scale(const char *arg)
2716
{
2717
    unsigned int stream;
2718
    double scale;
2719
    char *p;
2720

    
2721
    stream = strtol(arg, &p, 0);
2722
    if (*p)
2723
        p++;
2724
    scale= strtod(p, &p);
2725

    
2726
    if(stream >= MAX_STREAMS)
2727
        av_exit(1);
2728

    
2729
    input_files_ts_scale[nb_input_files][stream]= scale;
2730
}
2731

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

    
2738
static int opt_start_time(const char *opt, const char *arg)
2739
{
2740
    start_time = parse_time_or_die(opt, arg, 1);
2741
    return 0;
2742
}
2743

    
2744
static int opt_rec_timestamp(const char *opt, const char *arg)
2745
{
2746
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2747
    return 0;
2748
}
2749

    
2750
static int opt_input_ts_offset(const char *opt, const char *arg)
2751
{
2752
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2753
    return 0;
2754
}
2755

    
2756
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2757
{
2758
    const char *codec_string = encoder ? "encoder" : "decoder";
2759
    AVCodec *codec;
2760

    
2761
    if(!name)
2762
        return CODEC_ID_NONE;
2763
    codec = encoder ?
2764
        avcodec_find_encoder_by_name(name) :
2765
        avcodec_find_decoder_by_name(name);
2766
    if(!codec) {
2767
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2768
        av_exit(1);
2769
    }
2770
    if(codec->type != type) {
2771
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2772
        av_exit(1);
2773
    }
2774
    return codec->id;
2775
}
2776

    
2777
static void opt_input_file(const char *filename)
2778
{
2779
    AVFormatContext *ic;
2780
    AVFormatParameters params, *ap = &params;
2781
    int err, i, ret, rfps, rfps_base;
2782
    int64_t timestamp;
2783

    
2784
    if (!strcmp(filename, "-"))
2785
        filename = "pipe:";
2786

    
2787
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2788
                    !strcmp(filename, "/dev/stdin");
2789

    
2790
    /* get default parameters from command line */
2791
    ic = avformat_alloc_context();
2792

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

    
2810
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2811

    
2812
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2813
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2814
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2815
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2816

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

    
2830
    ic->loop_input = loop_input;
2831

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

    
2840
    timestamp = start_time;
2841
    /* add the stream start time */
2842
    if (ic->start_time != AV_NOPTS_VALUE)
2843
        timestamp += ic->start_time;
2844

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

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

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

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

    
2896
                    (float)rfps / rfps_base, rfps, rfps_base);
2897
            }
2898
            /* update the current frame rate to match the stream frame rate */
2899
            frame_rate.num = rfps;
2900
            frame_rate.den = rfps_base;
2901

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

    
2924
    input_files[nb_input_files] = ic;
2925
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2926
    /* dump the file content */
2927
    if (verbose >= 0)
2928
        dump_format(ic, nb_input_files, filename, 0);
2929

    
2930
    nb_input_files++;
2931
    file_iformat = NULL;
2932
    file_oformat = NULL;
2933

    
2934
    video_channel = 0;
2935

    
2936
    av_freep(&video_codec_name);
2937
    av_freep(&audio_codec_name);
2938
    av_freep(&subtitle_codec_name);
2939
}
2940

    
2941
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2942
                                         int *has_subtitle_ptr)
2943
{
2944
    int has_video, has_audio, has_subtitle, i, j;
2945
    AVFormatContext *ic;
2946

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

    
2978
static void new_video_stream(AVFormatContext *oc)
2979
{
2980
    AVStream *st;
2981
    AVCodecContext *video_enc;
2982
    int codec_id;
2983

    
2984
    st = av_new_stream(oc, oc->nb_streams);
2985
    if (!st) {
2986
        fprintf(stderr, "Could not alloc stream\n");
2987
        av_exit(1);
2988
    }
2989
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2990
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2991
    video_bitstream_filters= NULL;
2992

    
2993
    if(thread_count>1)
2994
        avcodec_thread_init(st->codec, thread_count);
2995

    
2996
    video_enc = st->codec;
2997

    
2998
    if(video_codec_tag)
2999
        video_enc->codec_tag= video_codec_tag;
3000

    
3001
    if(   (video_global_header&1)
3002
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3003
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3004
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3005
    }
3006
    if(video_global_header&2){
3007
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3008
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3009
    }
3010

    
3011
    if (video_stream_copy) {
3012
        st->stream_copy = 1;
3013
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3014
        video_enc->sample_aspect_ratio =
3015
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3016
    } else {
3017
        const char *p;
3018
        int i;
3019
        AVCodec *codec;
3020
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3021

    
3022
        if (video_codec_name) {
3023
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3024
            codec = avcodec_find_encoder_by_name(video_codec_name);
3025
            output_codecs[nb_ocodecs] = codec;
3026
        } else {
3027
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3028
            codec = avcodec_find_encoder(codec_id);
3029
        }
3030

    
3031
        video_enc->codec_id = codec_id;
3032

    
3033
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3034

    
3035
        if (codec && codec->supported_framerates && !force_fps)
3036
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3037
        video_enc->time_base.den = fps.num;
3038
        video_enc->time_base.num = fps.den;
3039

    
3040
        video_enc->width = frame_width + frame_padright + frame_padleft;
3041
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3042
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3043
        video_enc->pix_fmt = frame_pix_fmt;
3044
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3045

    
3046
        if(codec && codec->pix_fmts){
3047
            const enum PixelFormat *p= codec->pix_fmts;
3048
            for(; *p!=-1; p++){
3049
                if(*p == video_enc->pix_fmt)
3050
                    break;
3051
            }
3052
            if(*p == -1)
3053
                video_enc->pix_fmt = codec->pix_fmts[0];
3054
        }
3055

    
3056
        if (intra_only)
3057
            video_enc->gop_size = 0;
3058
        if (video_qscale || same_quality) {
3059
            video_enc->flags |= CODEC_FLAG_QSCALE;
3060
            video_enc->global_quality=
3061
                st->quality = FF_QP2LAMBDA * video_qscale;
3062
        }
3063

    
3064
        if(intra_matrix)
3065
            video_enc->intra_matrix = intra_matrix;
3066
        if(inter_matrix)
3067
            video_enc->inter_matrix = inter_matrix;
3068

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

    
3100
        if (do_psnr)
3101
            video_enc->flags|= CODEC_FLAG_PSNR;
3102

    
3103
        /* two pass mode */
3104
        if (do_pass) {
3105
            if (do_pass == 1) {
3106
                video_enc->flags |= CODEC_FLAG_PASS1;
3107
            } else {
3108
                video_enc->flags |= CODEC_FLAG_PASS2;
3109
            }
3110
        }
3111
    }
3112
    nb_ocodecs++;
3113

    
3114
    /* reset some key parameters */
3115
    video_disable = 0;
3116
    av_freep(&video_codec_name);
3117
    video_stream_copy = 0;
3118
}
3119

    
3120
static void new_audio_stream(AVFormatContext *oc)
3121
{
3122
    AVStream *st;
3123
    AVCodecContext *audio_enc;
3124
    int codec_id;
3125

    
3126
    st = av_new_stream(oc, oc->nb_streams);
3127
    if (!st) {
3128
        fprintf(stderr, "Could not alloc stream\n");
3129
        av_exit(1);
3130
    }
3131
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3132

    
3133
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3134
    audio_bitstream_filters= NULL;
3135

    
3136
    if(thread_count>1)
3137
        avcodec_thread_init(st->codec, thread_count);
3138

    
3139
    audio_enc = st->codec;
3140
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3141

    
3142
    if(audio_codec_tag)
3143
        audio_enc->codec_tag= audio_codec_tag;
3144

    
3145
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3146
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3147
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3148
    }
3149
    if (audio_stream_copy) {
3150
        st->stream_copy = 1;
3151
        audio_enc->channels = audio_channels;
3152
    } else {
3153
        AVCodec *codec;
3154

    
3155
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3156

    
3157
        if (audio_codec_name) {
3158
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3159
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3160
            output_codecs[nb_ocodecs] = codec;
3161
        } else {
3162
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3163
            codec = avcodec_find_encoder(codec_id);
3164
        }
3165
        audio_enc->codec_id = codec_id;
3166

    
3167
        if (audio_qscale > QSCALE_NONE) {
3168
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3169
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3170
        }
3171
        audio_enc->thread_count = thread_count;
3172
        audio_enc->channels = audio_channels;
3173
        audio_enc->sample_fmt = audio_sample_fmt;
3174
        audio_enc->channel_layout = channel_layout;
3175
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3176
            audio_enc->channel_layout = 0;
3177

    
3178
        if(codec && codec->sample_fmts){
3179
            const enum SampleFormat *p= codec->sample_fmts;
3180
            for(; *p!=-1; p++){
3181
                if(*p == audio_enc->sample_fmt)
3182
                    break;
3183
            }
3184
            if(*p == -1)
3185
                audio_enc->sample_fmt = codec->sample_fmts[0];
3186
        }
3187
    }
3188
    nb_ocodecs++;
3189
    audio_enc->sample_rate = audio_sample_rate;
3190
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3191
    if (audio_language) {
3192
        av_metadata_set(&st->metadata, "language", audio_language);
3193
        av_free(audio_language);
3194
        audio_language = NULL;
3195
    }
3196

    
3197
    /* reset some key parameters */
3198
    audio_disable = 0;
3199
    av_freep(&audio_codec_name);
3200
    audio_stream_copy = 0;
3201
}
3202

    
3203
static void new_subtitle_stream(AVFormatContext *oc)
3204
{
3205
    AVStream *st;
3206
    AVCodecContext *subtitle_enc;
3207

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

    
3215
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3216
    subtitle_bitstream_filters= NULL;
3217

    
3218
    subtitle_enc = st->codec;
3219
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3220

    
3221
    if(subtitle_codec_tag)
3222
        subtitle_enc->codec_tag= subtitle_codec_tag;
3223

    
3224
    if (subtitle_stream_copy) {
3225
        st->stream_copy = 1;
3226
    } else {
3227
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3228
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3229
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3230
    }
3231
    nb_ocodecs++;
3232

    
3233
    if (subtitle_language) {
3234
        av_metadata_set(&st->metadata, "language", subtitle_language);
3235
        av_free(subtitle_language);
3236
        subtitle_language = NULL;
3237
    }
3238

    
3239
    subtitle_disable = 0;
3240
    av_freep(&subtitle_codec_name);
3241
    subtitle_stream_copy = 0;
3242
}
3243

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

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

    
3266
static void opt_new_subtitle_stream(void)
3267
{
3268
    AVFormatContext *oc;
3269
    if (nb_output_files <= 0) {
3270
        fprintf(stderr, "At least one output file must be specified\n");
3271
        av_exit(1);
3272
    }
3273
    oc = output_files[nb_output_files - 1];
3274
    new_subtitle_stream(oc);
3275
}
3276

    
3277
static void opt_output_file(const char *filename)
3278
{
3279
    AVFormatContext *oc;
3280
    int use_video, use_audio, use_subtitle;
3281
    int input_has_video, input_has_audio, input_has_subtitle;
3282
    AVFormatParameters params, *ap = &params;
3283

    
3284
    if (!strcmp(filename, "-"))
3285
        filename = "pipe:";
3286

    
3287
    oc = avformat_alloc_context();
3288

    
3289
    if (!file_oformat) {
3290
        file_oformat = guess_format(NULL, filename, NULL);
3291
        if (!file_oformat) {
3292
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3293
                    filename);
3294
            av_exit(1);
3295
        }
3296
    }
3297

    
3298
    oc->oformat = file_oformat;
3299
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3300

    
3301
    if (!strcmp(file_oformat->name, "ffm") &&
3302
        av_strstart(filename, "http:", NULL)) {
3303
        /* special case for files sent to ffserver: we get the stream
3304
           parameters from ffserver */
3305
        int err = read_ffserver_streams(oc, filename);
3306
        if (err < 0) {
3307
            print_error(filename, err);
3308
            av_exit(1);
3309
        }
3310
    } else {
3311
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3312
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3313
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3314

    
3315
        /* disable if no corresponding type found and at least one
3316
           input file */
3317
        if (nb_input_files > 0) {
3318
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3319
                                         &input_has_subtitle);
3320
            if (!input_has_video)
3321
                use_video = 0;
3322
            if (!input_has_audio)
3323
                use_audio = 0;
3324
            if (!input_has_subtitle)
3325
                use_subtitle = 0;
3326
        }
3327

    
3328
        /* manual disable */
3329
        if (audio_disable) {
3330
            use_audio = 0;
3331
        }
3332
        if (video_disable) {
3333
            use_video = 0;
3334
        }
3335
        if (subtitle_disable) {
3336
            use_subtitle = 0;
3337
        }
3338

    
3339
        if (use_video) {
3340
            new_video_stream(oc);
3341
        }
3342

    
3343
        if (use_audio) {
3344
            new_audio_stream(oc);
3345
        }
3346

    
3347
        if (use_subtitle) {
3348
            new_subtitle_stream(oc);
3349
        }
3350

    
3351
        oc->timestamp = rec_timestamp;
3352

    
3353
        for(; metadata_count>0; metadata_count--){
3354
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3355
                                           metadata[metadata_count-1].value);
3356
        }
3357
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3358
    }
3359

    
3360
    output_files[nb_output_files++] = oc;
3361

    
3362
    /* check filename in case of an image number is expected */
3363
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3364
        if (!av_filename_number_test(oc->filename)) {
3365
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3366
            av_exit(1);
3367
        }
3368
    }
3369

    
3370
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3371
        /* test if it already exists to avoid loosing precious files */
3372
        if (!file_overwrite &&
3373
            (strchr(filename, ':') == NULL ||
3374
             filename[1] == ':' ||
3375
             av_strstart(filename, "file:", NULL))) {
3376
            if (url_exist(filename)) {
3377
                if (!using_stdin) {
3378
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3379
                    fflush(stderr);
3380
                    if (!read_yesno()) {
3381
                        fprintf(stderr, "Not overwriting - exiting\n");
3382
                        av_exit(1);
3383
                    }
3384
                }
3385
                else {
3386
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3387
                    av_exit(1);
3388
                }
3389
            }
3390
        }
3391

    
3392
        /* open the file */
3393
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3394
            fprintf(stderr, "Could not open '%s'\n", filename);
3395
            av_exit(1);
3396
        }
3397
    }
3398

    
3399
    memset(ap, 0, sizeof(*ap));
3400
    if (av_set_parameters(oc, ap) < 0) {
3401
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3402
                oc->filename);
3403
        av_exit(1);
3404
    }
3405

    
3406
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3407
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3408
    oc->loop_output = loop_output;
3409
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3410

    
3411
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3412

    
3413
    /* reset some options */
3414
    file_oformat = NULL;
3415
    file_iformat = NULL;
3416
}
3417

    
3418
/* same option as mencoder */
3419
static void opt_pass(const char *pass_str)
3420
{
3421
    int pass;
3422
    pass = atoi(pass_str);
3423
    if (pass != 1 && pass != 2) {
3424
        fprintf(stderr, "pass number can be only 1 or 2\n");
3425
        av_exit(1);
3426
    }
3427
    do_pass = pass;
3428
}
3429

    
3430
static int64_t getutime(void)
3431
{
3432
#if HAVE_GETRUSAGE
3433
    struct rusage rusage;
3434

    
3435
    getrusage(RUSAGE_SELF, &rusage);
3436
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3437
#elif HAVE_GETPROCESSTIMES
3438
    HANDLE proc;
3439
    FILETIME c, e, k, u;
3440
    proc = GetCurrentProcess();
3441
    GetProcessTimes(proc, &c, &e, &k, &u);
3442
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3443
#else
3444
    return av_gettime();
3445
#endif
3446
}
3447

    
3448
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3449
{
3450
    int i;
3451
    const char *p = str;
3452
    for(i = 0;; i++) {
3453
        dest[i] = atoi(p);
3454
        if(i == 63)
3455
            break;
3456
        p = strchr(p, ',');
3457
        if(!p) {
3458
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3459
            av_exit(1);
3460
        }
3461
        p++;
3462
    }
3463
}
3464

    
3465
static void opt_inter_matrix(const char *arg)
3466
{
3467
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3468
    parse_matrix_coeffs(inter_matrix, arg);
3469
}
3470

    
3471
static void opt_intra_matrix(const char *arg)
3472
{
3473
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3474
    parse_matrix_coeffs(intra_matrix, arg);
3475
}
3476

    
3477
/**
3478
 * Trivial log callback.
3479
 * Only suitable for show_help and similar since it lacks prefix handling.
3480
 */
3481
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3482
{
3483
    vfprintf(stdout, fmt, vl);
3484
}
3485

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

    
3523
static void opt_target(const char *arg)
3524
{
3525
    int norm = -1;
3526
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3527

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

    
3572
    if(norm < 0) {
3573
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3574
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3575
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3576
        av_exit(1);
3577
    }
3578

    
3579
    if(!strcmp(arg, "vcd")) {
3580

    
3581
        opt_video_codec("mpeg1video");
3582
        opt_audio_codec("mp2");
3583
        opt_format("vcd");
3584

    
3585
        opt_frame_size(norm ? "352x240" : "352x288");
3586
        opt_frame_rate(NULL, frame_rates[norm]);
3587
        opt_default("gop", norm ? "18" : "15");
3588

    
3589
        opt_default("b", "1150000");
3590
        opt_default("maxrate", "1150000");
3591
        opt_default("minrate", "1150000");
3592
        opt_default("bufsize", "327680"); // 40*1024*8;
3593

    
3594
        opt_default("ab", "224000");
3595
        audio_sample_rate = 44100;
3596
        audio_channels = 2;
3597

    
3598
        opt_default("packetsize", "2324");
3599
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3600

    
3601
        /* We have to offset the PTS, so that it is consistent with the SCR.
3602
           SCR starts at 36000, but the first two packs contain only padding
3603
           and the first pack from the other stream, respectively, may also have
3604
           been written before.
3605
           So the real data starts at SCR 36000+3*1200. */
3606
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3607
    } else if(!strcmp(arg, "svcd")) {
3608

    
3609
        opt_video_codec("mpeg2video");
3610
        opt_audio_codec("mp2");
3611
        opt_format("svcd");
3612

    
3613
        opt_frame_size(norm ? "480x480" : "480x576");
3614
        opt_frame_rate(NULL, frame_rates[norm]);
3615
        opt_default("gop", norm ? "18" : "15");
3616

    
3617
        opt_default("b", "2040000");
3618
        opt_default("maxrate", "2516000");
3619
        opt_default("minrate", "0"); //1145000;
3620
        opt_default("bufsize", "1835008"); //224*1024*8;
3621
        opt_default("flags", "+scan_offset");
3622

    
3623

    
3624
        opt_default("ab", "224000");
3625
        audio_sample_rate = 44100;
3626

    
3627
        opt_default("packetsize", "2324");
3628

    
3629
    } else if(!strcmp(arg, "dvd")) {
3630

    
3631
        opt_video_codec("mpeg2video");
3632
        opt_audio_codec("ac3");
3633
        opt_format("dvd");
3634

    
3635
        opt_frame_size(norm ? "720x480" : "720x576");
3636
        opt_frame_rate(NULL, frame_rates[norm]);
3637
        opt_default("gop", norm ? "18" : "15");
3638

    
3639
        opt_default("b", "6000000");
3640
        opt_default("maxrate", "9000000");
3641
        opt_default("minrate", "0"); //1500000;
3642
        opt_default("bufsize", "1835008"); //224*1024*8;
3643

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

    
3647
        opt_default("ab", "448000");
3648
        audio_sample_rate = 48000;
3649

    
3650
    } else if(!strncmp(arg, "dv", 2)) {
3651

    
3652
        opt_format("dv");
3653

    
3654
        opt_frame_size(norm ? "720x480" : "720x576");
3655
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3656
                                             (norm ? "yuv411p" : "yuv420p"));
3657
        opt_frame_rate(NULL, frame_rates[norm]);
3658

    
3659
        audio_sample_rate = 48000;
3660
        audio_channels = 2;
3661

    
3662
    } else {
3663
        fprintf(stderr, "Unknown target: %s\n", arg);
3664
        av_exit(1);
3665
    }
3666
}
3667

    
3668
static void opt_vstats_file (const char *arg)
3669
{
3670
    av_free (vstats_filename);
3671
    vstats_filename=av_strdup (arg);
3672
}
3673

    
3674
static void opt_vstats (void)
3675
{
3676
    char filename[40];
3677
    time_t today2 = time(NULL);
3678
    struct tm *today = localtime(&today2);
3679

    
3680
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3681
             today->tm_sec);
3682
    opt_vstats_file(filename);
3683
}
3684

    
3685
static int opt_bsf(const char *opt, const char *arg)
3686
{
3687
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3688
    AVBitStreamFilterContext **bsfp;
3689

    
3690
    if(!bsfc){
3691
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3692
        av_exit(1);
3693
    }
3694

    
3695
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3696
          *opt == 'a' ? &audio_bitstream_filters :
3697
                        &subtitle_bitstream_filters;
3698
    while(*bsfp)
3699
        bsfp= &(*bsfp)->next;
3700

    
3701
    *bsfp= bsfc;
3702

    
3703
    return 0;
3704
}
3705

    
3706
static int opt_preset(const char *opt, const char *arg)
3707
{
3708
    FILE *f=NULL;
3709
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3710
    int i;
3711
    const char *base[2]= { getenv("HOME"),
3712
                           FFMPEG_DATADIR,
3713
                         };
3714

    
3715
    for(i=!base[0]; i<2 && !f; i++){
3716
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3717
        f= fopen(filename, "r");
3718
        if(!f){
3719
            char *codec_name= *opt == 'v' ? video_codec_name :
3720
                              *opt == 'a' ? audio_codec_name :
3721
                                            subtitle_codec_name;
3722
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3723
            f= fopen(filename, "r");
3724
        }
3725
    }
3726
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3727
              is_dos_path(arg))){
3728
        av_strlcpy(filename, arg, sizeof(filename));
3729
        f= fopen(filename, "r");
3730
    }
3731

    
3732
    if(!f){
3733
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3734
        av_exit(1);
3735
    }
3736

    
3737
    while(!feof(f)){
3738
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3739
        if(line[0] == '#' && !e)
3740
            continue;
3741
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3742
        if(e){
3743
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3744
            av_exit(1);
3745
        }
3746
        if(!strcmp(tmp, "acodec")){
3747
            opt_audio_codec(tmp2);
3748
        }else if(!strcmp(tmp, "vcodec")){
3749
            opt_video_codec(tmp2);
3750
        }else if(!strcmp(tmp, "scodec")){
3751
            opt_subtitle_codec(tmp2);
3752
        }else if(opt_default(tmp, tmp2) < 0){
3753
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3754
            av_exit(1);
3755
        }
3756
    }
3757

    
3758
    fclose(f);
3759

    
3760
    return 0;
3761
}
3762

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

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

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

    
3862
    /* subtitle options */
3863
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3864
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3865
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3866
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3867
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3868

    
3869
    /* grab options */
3870
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3871
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3872
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3873

    
3874
    /* muxer options */
3875
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3876
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3877

    
3878
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3879
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3880
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3881

    
3882
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3883
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3884
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3885

    
3886
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3887
    { NULL, },
3888
};
3889

    
3890
int main(int argc, char **argv)
3891
{
3892
    int i;
3893
    int64_t ti;
3894

    
3895
    avcodec_register_all();
3896
    avdevice_register_all();
3897
    av_register_all();
3898

    
3899
    if(isatty(STDIN_FILENO))
3900
        url_set_interrupt_cb(decode_interrupt_cb);
3901

    
3902
    for(i=0; i<CODEC_TYPE_NB; i++){
3903
        avcodec_opts[i]= avcodec_alloc_context2(i);
3904
    }
3905
    avformat_opts = avformat_alloc_context();
3906
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3907

    
3908
    show_banner();
3909

    
3910
    /* parse options */
3911
    parse_options(argc, argv, options, opt_output_file);
3912

    
3913
    /* file converter / grab */
3914
    if (nb_output_files <= 0) {
3915
        fprintf(stderr, "At least one output file must be specified\n");
3916
        av_exit(1);
3917
    }
3918

    
3919
    if (nb_input_files == 0) {
3920
        fprintf(stderr, "At least one input file must be specified\n");
3921
        av_exit(1);
3922
    }
3923

    
3924
    ti = getutime();
3925
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3926
                  stream_maps, nb_stream_maps) < 0)
3927
        av_exit(1);
3928
    ti = getutime() - ti;
3929
    if (do_benchmark) {
3930
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3931
    }
3932

    
3933
    return av_exit(0);
3934
}