Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ fdf11906

History | View | Annotate | Download (138 KB)

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

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

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

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

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

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

    
65
#include "cmdutils.h"
66

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

    
70
#undef exit
71

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

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

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

    
89
static const OptionDef options[];
90

    
91
#define MAX_FILES 20
92

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

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

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

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

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

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

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

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

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

    
196
static int rate_emu = 0;
197

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

    
201
static int audio_volume = 256;
202

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

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

    
220
static unsigned int sws_flags = SWS_BICUBIC;
221

    
222
static int64_t timer_start;
223

    
224
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
225
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
226
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
227
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
228

    
229
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
230

    
231
struct AVInputStream;
232

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

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

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

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

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

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

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

    
292
#if HAVE_TERMIOS_H
293

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

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

    
305
static volatile sig_atomic_t received_sigterm = 0;
306

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
416
    av_free(opt_names);
417

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

    
422
    av_free(video_standard);
423

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
511
        bsfc= bsfc->next;
512
    }
513

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

    
521
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
522

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
675
            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
676

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
850
    *frame_size = 0;
851

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1072

    
1073
    oc = output_files[0];
1074

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

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

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

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

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

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

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

    
1154
        fflush(stderr);
1155
    }
1156

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1536
    return -1;
1537
}
1538

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1723
        codec = ost->st->codec;
1724
        icodec = ist->st->codec;
1725

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

    
1730
        ost->st->disposition = ist->st->disposition;
1731

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

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

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

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

    
1897
    if (!bit_buffer)
1898
        bit_buffer = av_malloc(bit_buffer_size);
1899
    if (!bit_buffer)
1900
        goto fail;
1901

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

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

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

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

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

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

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

    
1997
        out_file = output_files[out_file_index];
1998
        in_file = input_files[in_file_index];
1999

    
2000

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

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

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

    
2030
    key = -1;
2031
    timer_start = av_gettime();
2032

    
2033
    for(; received_sigterm == 0;) {
2034
        int file_index, ist_index;
2035
        AVPacket pkt;
2036
        double ipts_min;
2037
        double opts_min;
2038

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

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

    
2085
        /* finish if recording time exhausted */
2086
        if (opts_min >= (recording_time / 1000000.0))
2087
            break;
2088

    
2089
        /* finish if limit size exhausted */
2090
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2091
            break;
2092

    
2093
        /* read a frame from it and output it in the fifo */
2094
        is = input_files[file_index];
2095
        ret= av_read_frame(is, &pkt);
2096
        if(ret == AVERROR(EAGAIN) && strcmp(is->iformat->name, "ffm"))
2097
            continue;
2098
        if (ret < 0) {
2099
            file_table[file_index].eof_reached = 1;
2100
            if (opt_shortest)
2101
                break;
2102
            else
2103
                continue;
2104
        }
2105

    
2106
        if (do_pkt_dump) {
2107
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2108
        }
2109
        /* the following test is needed in case new streams appear
2110
           dynamically in stream : we ignore them */
2111
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2112
            goto discard_packet;
2113
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2114
        ist = ist_table[ist_index];
2115
        if (ist->discard)
2116
            goto discard_packet;
2117

    
2118
        if (pkt.dts != AV_NOPTS_VALUE)
2119
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2120
        if (pkt.pts != AV_NOPTS_VALUE)
2121
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2122

    
2123
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2124
            if(pkt.pts != AV_NOPTS_VALUE)
2125
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2126
            if(pkt.dts != AV_NOPTS_VALUE)
2127
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2128
        }
2129

    
2130
//        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);
2131
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2132
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2133
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2134
            int64_t delta= pkt_dts - ist->next_pts;
2135
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2136
                input_files_ts_offset[ist->file_index]-= delta;
2137
                if (verbose > 2)
2138
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2139
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2140
                if(pkt.pts != AV_NOPTS_VALUE)
2141
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2142
            }
2143
        }
2144

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

    
2148
            if (verbose >= 0)
2149
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2150
                        ist->file_index, ist->index);
2151
            if (exit_on_error)
2152
                av_exit(1);
2153
            av_free_packet(&pkt);
2154
            goto redo;
2155
        }
2156

    
2157
    discard_packet:
2158
        av_free_packet(&pkt);
2159

    
2160
        /* dump report by using the output first video and audio streams */
2161
        print_report(output_files, ost_table, nb_ostreams, 0);
2162
    }
2163

    
2164
    /* at the end of stream, we must flush the decoder buffers */
2165
    for(i=0;i<nb_istreams;i++) {
2166
        ist = ist_table[i];
2167
        if (ist->decoding_needed) {
2168
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2169
        }
2170
    }
2171

    
2172
    term_exit();
2173

    
2174
    /* write the trailer if needed and close file */
2175
    for(i=0;i<nb_output_files;i++) {
2176
        os = output_files[i];
2177
        av_write_trailer(os);
2178
    }
2179

    
2180
    /* dump report by using the first video and audio streams */
2181
    print_report(output_files, ost_table, nb_ostreams, 1);
2182

    
2183
    /* close each encoder */
2184
    for(i=0;i<nb_ostreams;i++) {
2185
        ost = ost_table[i];
2186
        if (ost->encoding_needed) {
2187
            av_freep(&ost->st->codec->stats_in);
2188
            avcodec_close(ost->st->codec);
2189
        }
2190
    }
2191

    
2192
    /* close each decoder */
2193
    for(i=0;i<nb_istreams;i++) {
2194
        ist = ist_table[i];
2195
        if (ist->decoding_needed) {
2196
            avcodec_close(ist->st->codec);
2197
        }
2198
    }
2199

    
2200
    /* finished ! */
2201

    
2202
    ret = 0;
2203
 fail1:
2204
    av_freep(&bit_buffer);
2205
    av_free(file_table);
2206

    
2207
    if (ist_table) {
2208
        for(i=0;i<nb_istreams;i++) {
2209
            ist = ist_table[i];
2210
            av_free(ist);
2211
        }
2212
        av_free(ist_table);
2213
    }
2214
    if (ost_table) {
2215
        for(i=0;i<nb_ostreams;i++) {
2216
            ost = ost_table[i];
2217
            if (ost) {
2218
                if (ost->logfile) {
2219
                    fclose(ost->logfile);
2220
                    ost->logfile = NULL;
2221
                }
2222
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2223
                                             initialized but set to zero */
2224
                av_free(ost->pict_tmp.data[0]);
2225
                if (ost->video_resample)
2226
                    sws_freeContext(ost->img_resample_ctx);
2227
                if (ost->resample)
2228
                    audio_resample_close(ost->resample);
2229
                if (ost->reformat_ctx)
2230
                    av_audio_convert_free(ost->reformat_ctx);
2231
                av_free(ost);
2232
            }
2233
        }
2234
        av_free(ost_table);
2235
    }
2236
    return ret;
2237
 fail:
2238
    ret = AVERROR(ENOMEM);
2239
    goto fail1;
2240
}
2241

    
2242
#if 0
2243
int file_read(const char *filename)
2244
{
2245
    URLContext *h;
2246
    unsigned char buffer[1024];
2247
    int len, i;
2248

2249
    if (url_open(&h, filename, O_RDONLY) < 0) {
2250
        printf("could not open '%s'\n", filename);
2251
        return -1;
2252
    }
2253
    for(;;) {
2254
        len = url_read(h, buffer, sizeof(buffer));
2255
        if (len <= 0)
2256
            break;
2257
        for(i=0;i<len;i++) putchar(buffer[i]);
2258
    }
2259
    url_close(h);
2260
    return 0;
2261
}
2262
#endif
2263

    
2264
static void opt_format(const char *arg)
2265
{
2266
    /* compatibility stuff for pgmyuv */
2267
    if (!strcmp(arg, "pgmyuv")) {
2268
        pgmyuv_compatibility_hack=1;
2269
//        opt_image_format(arg);
2270
        arg = "image2";
2271
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2272
    }
2273

    
2274
    file_iformat = av_find_input_format(arg);
2275
    file_oformat = guess_format(arg, NULL, NULL);
2276
    if (!file_iformat && !file_oformat) {
2277
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2278
        av_exit(1);
2279
    }
2280
}
2281

    
2282
static void opt_video_rc_override_string(const char *arg)
2283
{
2284
    video_rc_override_string = arg;
2285
}
2286

    
2287
static int opt_me_threshold(const char *opt, const char *arg)
2288
{
2289
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2290
    return 0;
2291
}
2292

    
2293
static int opt_verbose(const char *opt, const char *arg)
2294
{
2295
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2296
    av_log_set_level(verbose);
2297
    return 0;
2298
}
2299

    
2300
static int opt_frame_rate(const char *opt, const char *arg)
2301
{
2302
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2303
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2304
        av_exit(1);
2305
    }
2306
    return 0;
2307
}
2308

    
2309
static int opt_bitrate(const char *opt, const char *arg)
2310
{
2311
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2312

    
2313
    opt_default(opt, arg);
2314

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

    
2318
    return 0;
2319
}
2320

    
2321
static void opt_frame_crop_top(const char *arg)
2322
{
2323
    frame_topBand = atoi(arg);
2324
    if (frame_topBand < 0) {
2325
        fprintf(stderr, "Incorrect top crop size\n");
2326
        av_exit(1);
2327
    }
2328
    if ((frame_topBand % 2) != 0) {
2329
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2330
        av_exit(1);
2331
    }
2332
    if ((frame_topBand) >= frame_height){
2333
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2334
        av_exit(1);
2335
    }
2336
    frame_height -= frame_topBand;
2337
}
2338

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

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

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

    
2393
static void opt_frame_size(const char *arg)
2394
{
2395
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2396
        fprintf(stderr, "Incorrect frame size\n");
2397
        av_exit(1);
2398
    }
2399
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2400
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2401
        av_exit(1);
2402
    }
2403
}
2404

    
2405

    
2406
#define SCALEBITS 10
2407
#define ONE_HALF  (1 << (SCALEBITS - 1))
2408
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2409

    
2410
#define RGB_TO_Y(r, g, b) \
2411
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2412
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2413

    
2414
#define RGB_TO_U(r1, g1, b1, shift)\
2415
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2416
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2417

    
2418
#define RGB_TO_V(r1, g1, b1, shift)\
2419
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2420
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2421

    
2422
static void opt_pad_color(const char *arg) {
2423
    /* Input is expected to be six hex digits similar to
2424
       how colors are expressed in html tags (but without the #) */
2425
    int rgb = strtol(arg, NULL, 16);
2426
    int r,g,b;
2427

    
2428
    r = (rgb >> 16);
2429
    g = ((rgb >> 8) & 255);
2430
    b = (rgb & 255);
2431

    
2432
    padcolor[0] = RGB_TO_Y(r,g,b);
2433
    padcolor[1] = RGB_TO_U(r,g,b,0);
2434
    padcolor[2] = RGB_TO_V(r,g,b,0);
2435
}
2436

    
2437
static void opt_frame_pad_top(const char *arg)
2438
{
2439
    frame_padtop = atoi(arg);
2440
    if (frame_padtop < 0) {
2441
        fprintf(stderr, "Incorrect top pad size\n");
2442
        av_exit(1);
2443
    }
2444
    if ((frame_padtop % 2) != 0) {
2445
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2446
        av_exit(1);
2447
    }
2448
}
2449

    
2450
static void opt_frame_pad_bottom(const char *arg)
2451
{
2452
    frame_padbottom = atoi(arg);
2453
    if (frame_padbottom < 0) {
2454
        fprintf(stderr, "Incorrect bottom pad size\n");
2455
        av_exit(1);
2456
    }
2457
    if ((frame_padbottom % 2) != 0) {
2458
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2459
        av_exit(1);
2460
    }
2461
}
2462

    
2463

    
2464
static void opt_frame_pad_left(const char *arg)
2465
{
2466
    frame_padleft = atoi(arg);
2467
    if (frame_padleft < 0) {
2468
        fprintf(stderr, "Incorrect left pad size\n");
2469
        av_exit(1);
2470
    }
2471
    if ((frame_padleft % 2) != 0) {
2472
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2473
        av_exit(1);
2474
    }
2475
}
2476

    
2477

    
2478
static void opt_frame_pad_right(const char *arg)
2479
{
2480
    frame_padright = atoi(arg);
2481
    if (frame_padright < 0) {
2482
        fprintf(stderr, "Incorrect right pad size\n");
2483
        av_exit(1);
2484
    }
2485
    if ((frame_padright % 2) != 0) {
2486
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2487
        av_exit(1);
2488
    }
2489
}
2490

    
2491
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2492
{
2493
    int i;
2494
    char fmt_str[128];
2495
    for (i=-1; i < nb_fmts; i++) {
2496
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2497
        fprintf(stdout, "%s\n", fmt_str);
2498
    }
2499
}
2500

    
2501
static void opt_frame_pix_fmt(const char *arg)
2502
{
2503
    if (strcmp(arg, "list"))
2504
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2505
    else {
2506
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2507
        av_exit(0);
2508
    }
2509
}
2510

    
2511
static void opt_frame_aspect_ratio(const char *arg)
2512
{
2513
    int x = 0, y = 0;
2514
    double ar = 0;
2515
    const char *p;
2516
    char *end;
2517

    
2518
    p = strchr(arg, ':');
2519
    if (p) {
2520
        x = strtol(arg, &end, 10);
2521
        if (end == p)
2522
            y = strtol(end+1, &end, 10);
2523
        if (x > 0 && y > 0)
2524
            ar = (double)x / (double)y;
2525
    } else
2526
        ar = strtod(arg, NULL);
2527

    
2528
    if (!ar) {
2529
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2530
        av_exit(1);
2531
    }
2532
    frame_aspect_ratio = ar;
2533
}
2534

    
2535
static int opt_metadata(const char *opt, const char *arg)
2536
{
2537
    char *mid= strchr(arg, '=');
2538

    
2539
    if(!mid){
2540
        fprintf(stderr, "Missing =\n");
2541
        av_exit(1);
2542
    }
2543
    *mid++= 0;
2544

    
2545
    metadata_count++;
2546
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2547
    metadata[metadata_count-1].key  = av_strdup(arg);
2548
    metadata[metadata_count-1].value= av_strdup(mid);
2549

    
2550
    return 0;
2551
}
2552

    
2553
static void opt_qscale(const char *arg)
2554
{
2555
    video_qscale = atof(arg);
2556
    if (video_qscale <= 0 ||
2557
        video_qscale > 255) {
2558
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2559
        av_exit(1);
2560
    }
2561
}
2562

    
2563
static void opt_top_field_first(const char *arg)
2564
{
2565
    top_field_first= atoi(arg);
2566
}
2567

    
2568
static int opt_thread_count(const char *opt, const char *arg)
2569
{
2570
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2571
#if !HAVE_THREADS
2572
    if (verbose >= 0)
2573
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2574
#endif
2575
    return 0;
2576
}
2577

    
2578
static void opt_audio_sample_fmt(const char *arg)
2579
{
2580
    if (strcmp(arg, "list"))
2581
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2582
    else {
2583
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2584
        av_exit(0);
2585
    }
2586
}
2587

    
2588
static int opt_audio_rate(const char *opt, const char *arg)
2589
{
2590
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2591
    return 0;
2592
}
2593

    
2594
static int opt_audio_channels(const char *opt, const char *arg)
2595
{
2596
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2597
    return 0;
2598
}
2599

    
2600
static void opt_video_channel(const char *arg)
2601
{
2602
    video_channel = strtol(arg, NULL, 0);
2603
}
2604

    
2605
static void opt_video_standard(const char *arg)
2606
{
2607
    video_standard = av_strdup(arg);
2608
}
2609

    
2610
static void opt_codec(int *pstream_copy, char **pcodec_name,
2611
                      int codec_type, const char *arg)
2612
{
2613
    av_freep(pcodec_name);
2614
    if (!strcmp(arg, "copy")) {
2615
        *pstream_copy = 1;
2616
    } else {
2617
        *pcodec_name = av_strdup(arg);
2618
    }
2619
}
2620

    
2621
static void opt_audio_codec(const char *arg)
2622
{
2623
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2624
}
2625

    
2626
static void opt_audio_tag(const char *arg)
2627
{
2628
    char *tail;
2629
    audio_codec_tag= strtol(arg, &tail, 0);
2630

    
2631
    if(!tail || *tail)
2632
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2633
}
2634

    
2635
static void opt_video_tag(const char *arg)
2636
{
2637
    char *tail;
2638
    video_codec_tag= strtol(arg, &tail, 0);
2639

    
2640
    if(!tail || *tail)
2641
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2642
}
2643

    
2644
static void opt_video_codec(const char *arg)
2645
{
2646
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2647
}
2648

    
2649
static void opt_subtitle_codec(const char *arg)
2650
{
2651
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2652
}
2653

    
2654
static void opt_map(const char *arg)
2655
{
2656
    AVStreamMap *m;
2657
    char *p;
2658

    
2659
    m = &stream_maps[nb_stream_maps++];
2660

    
2661
    m->file_index = strtol(arg, &p, 0);
2662
    if (*p)
2663
        p++;
2664

    
2665
    m->stream_index = strtol(p, &p, 0);
2666
    if (*p) {
2667
        p++;
2668
        m->sync_file_index = strtol(p, &p, 0);
2669
        if (*p)
2670
            p++;
2671
        m->sync_stream_index = strtol(p, &p, 0);
2672
    } else {
2673
        m->sync_file_index = m->file_index;
2674
        m->sync_stream_index = m->stream_index;
2675
    }
2676
}
2677

    
2678
static void opt_map_meta_data(const char *arg)
2679
{
2680
    AVMetaDataMap *m;
2681
    char *p;
2682

    
2683
    m = &meta_data_maps[nb_meta_data_maps++];
2684

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

    
2689
    m->in_file = strtol(p, &p, 0);
2690
}
2691

    
2692
static void opt_input_ts_scale(const char *arg)
2693
{
2694
    unsigned int stream;
2695
    double scale;
2696
    char *p;
2697

    
2698
    stream = strtol(arg, &p, 0);
2699
    if (*p)
2700
        p++;
2701
    scale= strtod(p, &p);
2702

    
2703
    if(stream >= MAX_STREAMS)
2704
        av_exit(1);
2705

    
2706
    input_files_ts_scale[nb_input_files][stream]= scale;
2707
}
2708

    
2709
static int opt_recording_time(const char *opt, const char *arg)
2710
{
2711
    recording_time = parse_time_or_die(opt, arg, 1);
2712
    return 0;
2713
}
2714

    
2715
static int opt_start_time(const char *opt, const char *arg)
2716
{
2717
    start_time = parse_time_or_die(opt, arg, 1);
2718
    return 0;
2719
}
2720

    
2721
static int opt_rec_timestamp(const char *opt, const char *arg)
2722
{
2723
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2724
    return 0;
2725
}
2726

    
2727
static int opt_input_ts_offset(const char *opt, const char *arg)
2728
{
2729
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2730
    return 0;
2731
}
2732

    
2733
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2734
{
2735
    const char *codec_string = encoder ? "encoder" : "decoder";
2736
    AVCodec *codec;
2737

    
2738
    if(!name)
2739
        return CODEC_ID_NONE;
2740
    codec = encoder ?
2741
        avcodec_find_encoder_by_name(name) :
2742
        avcodec_find_decoder_by_name(name);
2743
    if(!codec) {
2744
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2745
        av_exit(1);
2746
    }
2747
    if(codec->type != type) {
2748
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2749
        av_exit(1);
2750
    }
2751
    return codec->id;
2752
}
2753

    
2754
static void opt_input_file(const char *filename)
2755
{
2756
    AVFormatContext *ic;
2757
    AVFormatParameters params, *ap = &params;
2758
    int err, i, ret, rfps, rfps_base;
2759
    int64_t timestamp;
2760

    
2761
    if (!strcmp(filename, "-"))
2762
        filename = "pipe:";
2763

    
2764
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2765
                    !strcmp(filename, "/dev/stdin");
2766

    
2767
    /* get default parameters from command line */
2768
    ic = avformat_alloc_context();
2769

    
2770
    memset(ap, 0, sizeof(*ap));
2771
    ap->prealloced_context = 1;
2772
    ap->sample_rate = audio_sample_rate;
2773
    ap->channels = audio_channels;
2774
    ap->time_base.den = frame_rate.num;
2775
    ap->time_base.num = frame_rate.den;
2776
    ap->width = frame_width + frame_padleft + frame_padright;
2777
    ap->height = frame_height + frame_padtop + frame_padbottom;
2778
    ap->pix_fmt = frame_pix_fmt;
2779
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2780
    ap->channel = video_channel;
2781
    ap->standard = video_standard;
2782
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2783
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2784
    if(pgmyuv_compatibility_hack)
2785
        ap->video_codec_id= CODEC_ID_PGMYUV;
2786

    
2787
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2788

    
2789
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2790
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2791
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2792

    
2793
    /* open the input file with generic libav function */
2794
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2795
    if (err < 0) {
2796
        print_error(filename, err);
2797
        av_exit(1);
2798
    }
2799
    if(opt_programid) {
2800
        int i;
2801
        for(i=0; i<ic->nb_programs; i++)
2802
            if(ic->programs[i]->id != opt_programid)
2803
                ic->programs[i]->discard = AVDISCARD_ALL;
2804
    }
2805

    
2806
    ic->loop_input = loop_input;
2807

    
2808
    /* If not enough info to get the stream parameters, we decode the
2809
       first frames to get it. (used in mpeg case for example) */
2810
    ret = av_find_stream_info(ic);
2811
    if (ret < 0 && verbose >= 0) {
2812
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2813
        av_exit(1);
2814
    }
2815

    
2816
    timestamp = start_time;
2817
    /* add the stream start time */
2818
    if (ic->start_time != AV_NOPTS_VALUE)
2819
        timestamp += ic->start_time;
2820

    
2821
    /* if seeking requested, we execute it */
2822
    if (start_time != 0) {
2823
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2824
        if (ret < 0) {
2825
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2826
                    filename, (double)timestamp / AV_TIME_BASE);
2827
        }
2828
        /* reset seek info */
2829
        start_time = 0;
2830
    }
2831

    
2832
    /* update the current parameters so that they match the one of the input stream */
2833
    for(i=0;i<ic->nb_streams;i++) {
2834
        AVCodecContext *enc = ic->streams[i]->codec;
2835
        if(thread_count>1)
2836
            avcodec_thread_init(enc, thread_count);
2837
        enc->thread_count= thread_count;
2838
        switch(enc->codec_type) {
2839
        case CODEC_TYPE_AUDIO:
2840
            set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2841
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2842
            channel_layout = enc->channel_layout;
2843
            audio_channels = enc->channels;
2844
            audio_sample_rate = enc->sample_rate;
2845
            audio_sample_fmt = enc->sample_fmt;
2846
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2847
            if(audio_disable)
2848
                ic->streams[i]->discard= AVDISCARD_ALL;
2849
            break;
2850
        case CODEC_TYPE_VIDEO:
2851
            set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2852
            frame_height = enc->height;
2853
            frame_width = enc->width;
2854
            if(ic->streams[i]->sample_aspect_ratio.num)
2855
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2856
            else
2857
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2858
            frame_aspect_ratio *= (float) enc->width / enc->height;
2859
            frame_pix_fmt = enc->pix_fmt;
2860
            rfps      = ic->streams[i]->r_frame_rate.num;
2861
            rfps_base = ic->streams[i]->r_frame_rate.den;
2862
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2863
            if(me_threshold)
2864
                enc->debug |= FF_DEBUG_MV;
2865

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

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

    
2872
                    (float)rfps / rfps_base, rfps, rfps_base);
2873
            }
2874
            /* update the current frame rate to match the stream frame rate */
2875
            frame_rate.num = rfps;
2876
            frame_rate.den = rfps_base;
2877

    
2878
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2879
            if(video_disable)
2880
                ic->streams[i]->discard= AVDISCARD_ALL;
2881
            else if(video_discard)
2882
                ic->streams[i]->discard= video_discard;
2883
            break;
2884
        case CODEC_TYPE_DATA:
2885
            break;
2886
        case CODEC_TYPE_SUBTITLE:
2887
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2888
            if(subtitle_disable)
2889
                ic->streams[i]->discard = AVDISCARD_ALL;
2890
            break;
2891
        case CODEC_TYPE_ATTACHMENT:
2892
        case CODEC_TYPE_UNKNOWN:
2893
            nb_icodecs++;
2894
            break;
2895
        default:
2896
            abort();
2897
        }
2898
    }
2899

    
2900
    input_files[nb_input_files] = ic;
2901
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2902
    /* dump the file content */
2903
    if (verbose >= 0)
2904
        dump_format(ic, nb_input_files, filename, 0);
2905

    
2906
    nb_input_files++;
2907
    file_iformat = NULL;
2908
    file_oformat = NULL;
2909

    
2910
    video_channel = 0;
2911

    
2912
    av_freep(&video_codec_name);
2913
    av_freep(&audio_codec_name);
2914
    av_freep(&subtitle_codec_name);
2915
}
2916

    
2917
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2918
                                         int *has_subtitle_ptr)
2919
{
2920
    int has_video, has_audio, has_subtitle, i, j;
2921
    AVFormatContext *ic;
2922

    
2923
    has_video = 0;
2924
    has_audio = 0;
2925
    has_subtitle = 0;
2926
    for(j=0;j<nb_input_files;j++) {
2927
        ic = input_files[j];
2928
        for(i=0;i<ic->nb_streams;i++) {
2929
            AVCodecContext *enc = ic->streams[i]->codec;
2930
            switch(enc->codec_type) {
2931
            case CODEC_TYPE_AUDIO:
2932
                has_audio = 1;
2933
                break;
2934
            case CODEC_TYPE_VIDEO:
2935
                has_video = 1;
2936
                break;
2937
            case CODEC_TYPE_SUBTITLE:
2938
                has_subtitle = 1;
2939
                break;
2940
            case CODEC_TYPE_DATA:
2941
            case CODEC_TYPE_ATTACHMENT:
2942
            case CODEC_TYPE_UNKNOWN:
2943
                break;
2944
            default:
2945
                abort();
2946
            }
2947
        }
2948
    }
2949
    *has_video_ptr = has_video;
2950
    *has_audio_ptr = has_audio;
2951
    *has_subtitle_ptr = has_subtitle;
2952
}
2953

    
2954
static void new_video_stream(AVFormatContext *oc)
2955
{
2956
    AVStream *st;
2957
    AVCodecContext *video_enc;
2958
    int codec_id;
2959

    
2960
    st = av_new_stream(oc, oc->nb_streams);
2961
    if (!st) {
2962
        fprintf(stderr, "Could not alloc stream\n");
2963
        av_exit(1);
2964
    }
2965
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2966
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2967
    video_bitstream_filters= NULL;
2968

    
2969
    if(thread_count>1)
2970
        avcodec_thread_init(st->codec, thread_count);
2971

    
2972
    video_enc = st->codec;
2973

    
2974
    if(video_codec_tag)
2975
        video_enc->codec_tag= video_codec_tag;
2976

    
2977
    if(   (video_global_header&1)
2978
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2979
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2980
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2981
    }
2982
    if(video_global_header&2){
2983
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2984
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2985
    }
2986

    
2987
    if (video_stream_copy) {
2988
        st->stream_copy = 1;
2989
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2990
        video_enc->sample_aspect_ratio =
2991
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2992
    } else {
2993
        const char *p;
2994
        int i;
2995
        AVCodec *codec;
2996
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2997

    
2998
        if (video_codec_name) {
2999
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3000
            codec = avcodec_find_encoder_by_name(video_codec_name);
3001
            output_codecs[nb_ocodecs] = codec;
3002
        } else {
3003
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3004
            codec = avcodec_find_encoder(codec_id);
3005
        }
3006

    
3007
        video_enc->codec_id = codec_id;
3008

    
3009
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3010

    
3011
        if (codec && codec->supported_framerates && !force_fps)
3012
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3013
        video_enc->time_base.den = fps.num;
3014
        video_enc->time_base.num = fps.den;
3015

    
3016
        video_enc->width = frame_width + frame_padright + frame_padleft;
3017
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3018
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3019
        video_enc->pix_fmt = frame_pix_fmt;
3020
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3021

    
3022
        if(codec && codec->pix_fmts){
3023
            const enum PixelFormat *p= codec->pix_fmts;
3024
            for(; *p!=-1; p++){
3025
                if(*p == video_enc->pix_fmt)
3026
                    break;
3027
            }
3028
            if(*p == -1)
3029
                video_enc->pix_fmt = codec->pix_fmts[0];
3030
        }
3031

    
3032
        if (intra_only)
3033
            video_enc->gop_size = 0;
3034
        if (video_qscale || same_quality) {
3035
            video_enc->flags |= CODEC_FLAG_QSCALE;
3036
            video_enc->global_quality=
3037
                st->quality = FF_QP2LAMBDA * video_qscale;
3038
        }
3039

    
3040
        if(intra_matrix)
3041
            video_enc->intra_matrix = intra_matrix;
3042
        if(inter_matrix)
3043
            video_enc->inter_matrix = inter_matrix;
3044

    
3045
        video_enc->thread_count = thread_count;
3046
        p= video_rc_override_string;
3047
        for(i=0; p; i++){
3048
            int start, end, q;
3049
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3050
            if(e!=3){
3051
                fprintf(stderr, "error parsing rc_override\n");
3052
                av_exit(1);
3053
            }
3054
            video_enc->rc_override=
3055
                av_realloc(video_enc->rc_override,
3056
                           sizeof(RcOverride)*(i+1));
3057
            video_enc->rc_override[i].start_frame= start;
3058
            video_enc->rc_override[i].end_frame  = end;
3059
            if(q>0){
3060
                video_enc->rc_override[i].qscale= q;
3061
                video_enc->rc_override[i].quality_factor= 1.0;
3062
            }
3063
            else{
3064
                video_enc->rc_override[i].qscale= 0;
3065
                video_enc->rc_override[i].quality_factor= -q/100.0;
3066
            }
3067
            p= strchr(p, '/');
3068
            if(p) p++;
3069
        }
3070
        video_enc->rc_override_count=i;
3071
        if (!video_enc->rc_initial_buffer_occupancy)
3072
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3073
        video_enc->me_threshold= me_threshold;
3074
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3075

    
3076
        if (do_psnr)
3077
            video_enc->flags|= CODEC_FLAG_PSNR;
3078

    
3079
        /* two pass mode */
3080
        if (do_pass) {
3081
            if (do_pass == 1) {
3082
                video_enc->flags |= CODEC_FLAG_PASS1;
3083
            } else {
3084
                video_enc->flags |= CODEC_FLAG_PASS2;
3085
            }
3086
        }
3087
    }
3088
    nb_ocodecs++;
3089

    
3090
    /* reset some key parameters */
3091
    video_disable = 0;
3092
    av_freep(&video_codec_name);
3093
    video_stream_copy = 0;
3094
}
3095

    
3096
static void new_audio_stream(AVFormatContext *oc)
3097
{
3098
    AVStream *st;
3099
    AVCodecContext *audio_enc;
3100
    int codec_id;
3101

    
3102
    st = av_new_stream(oc, oc->nb_streams);
3103
    if (!st) {
3104
        fprintf(stderr, "Could not alloc stream\n");
3105
        av_exit(1);
3106
    }
3107
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3108

    
3109
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3110
    audio_bitstream_filters= NULL;
3111

    
3112
    if(thread_count>1)
3113
        avcodec_thread_init(st->codec, thread_count);
3114

    
3115
    audio_enc = st->codec;
3116
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3117

    
3118
    if(audio_codec_tag)
3119
        audio_enc->codec_tag= audio_codec_tag;
3120

    
3121
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3122
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3123
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3124
    }
3125
    if (audio_stream_copy) {
3126
        st->stream_copy = 1;
3127
        audio_enc->channels = audio_channels;
3128
    } else {
3129
        AVCodec *codec;
3130

    
3131
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3132

    
3133
        if (audio_codec_name) {
3134
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3135
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3136
            output_codecs[nb_ocodecs] = codec;
3137
        } else {
3138
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3139
            codec = avcodec_find_encoder(codec_id);
3140
        }
3141
        audio_enc->codec_id = codec_id;
3142

    
3143
        if (audio_qscale > QSCALE_NONE) {
3144
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3145
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3146
        }
3147
        audio_enc->thread_count = thread_count;
3148
        audio_enc->channels = audio_channels;
3149
        audio_enc->sample_fmt = audio_sample_fmt;
3150
        audio_enc->channel_layout = channel_layout;
3151

    
3152
        if(codec && codec->sample_fmts){
3153
            const enum SampleFormat *p= codec->sample_fmts;
3154
            for(; *p!=-1; p++){
3155
                if(*p == audio_enc->sample_fmt)
3156
                    break;
3157
            }
3158
            if(*p == -1)
3159
                audio_enc->sample_fmt = codec->sample_fmts[0];
3160
        }
3161
    }
3162
    nb_ocodecs++;
3163
    audio_enc->sample_rate = audio_sample_rate;
3164
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3165
    if (audio_language) {
3166
        av_metadata_set(&st->metadata, "language", audio_language);
3167
        av_free(audio_language);
3168
        audio_language = NULL;
3169
    }
3170

    
3171
    /* reset some key parameters */
3172
    audio_disable = 0;
3173
    av_freep(&audio_codec_name);
3174
    audio_stream_copy = 0;
3175
}
3176

    
3177
static void new_subtitle_stream(AVFormatContext *oc)
3178
{
3179
    AVStream *st;
3180
    AVCodecContext *subtitle_enc;
3181

    
3182
    st = av_new_stream(oc, oc->nb_streams);
3183
    if (!st) {
3184
        fprintf(stderr, "Could not alloc stream\n");
3185
        av_exit(1);
3186
    }
3187
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3188

    
3189
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3190
    subtitle_bitstream_filters= NULL;
3191

    
3192
    subtitle_enc = st->codec;
3193
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3194
    if (subtitle_stream_copy) {
3195
        st->stream_copy = 1;
3196
    } else {
3197
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3198
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3199
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3200
    }
3201
    nb_ocodecs++;
3202

    
3203
    if (subtitle_language) {
3204
        av_metadata_set(&st->metadata, "language", subtitle_language);
3205
        av_free(subtitle_language);
3206
        subtitle_language = NULL;
3207
    }
3208

    
3209
    subtitle_disable = 0;
3210
    av_freep(&subtitle_codec_name);
3211
    subtitle_stream_copy = 0;
3212
}
3213

    
3214
static void opt_new_audio_stream(void)
3215
{
3216
    AVFormatContext *oc;
3217
    if (nb_output_files <= 0) {
3218
        fprintf(stderr, "At least one output file must be specified\n");
3219
        av_exit(1);
3220
    }
3221
    oc = output_files[nb_output_files - 1];
3222
    new_audio_stream(oc);
3223
}
3224

    
3225
static void opt_new_video_stream(void)
3226
{
3227
    AVFormatContext *oc;
3228
    if (nb_output_files <= 0) {
3229
        fprintf(stderr, "At least one output file must be specified\n");
3230
        av_exit(1);
3231
    }
3232
    oc = output_files[nb_output_files - 1];
3233
    new_video_stream(oc);
3234
}
3235

    
3236
static void opt_new_subtitle_stream(void)
3237
{
3238
    AVFormatContext *oc;
3239
    if (nb_output_files <= 0) {
3240
        fprintf(stderr, "At least one output file must be specified\n");
3241
        av_exit(1);
3242
    }
3243
    oc = output_files[nb_output_files - 1];
3244
    new_subtitle_stream(oc);
3245
}
3246

    
3247
static void opt_output_file(const char *filename)
3248
{
3249
    AVFormatContext *oc;
3250
    int use_video, use_audio, use_subtitle;
3251
    int input_has_video, input_has_audio, input_has_subtitle;
3252
    AVFormatParameters params, *ap = &params;
3253

    
3254
    if (!strcmp(filename, "-"))
3255
        filename = "pipe:";
3256

    
3257
    oc = avformat_alloc_context();
3258

    
3259
    if (!file_oformat) {
3260
        file_oformat = guess_format(NULL, filename, NULL);
3261
        if (!file_oformat) {
3262
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3263
                    filename);
3264
            av_exit(1);
3265
        }
3266
    }
3267

    
3268
    oc->oformat = file_oformat;
3269
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3270

    
3271
    if (!strcmp(file_oformat->name, "ffm") &&
3272
        av_strstart(filename, "http:", NULL)) {
3273
        /* special case for files sent to ffserver: we get the stream
3274
           parameters from ffserver */
3275
        int err = read_ffserver_streams(oc, filename);
3276
        if (err < 0) {
3277
            print_error(filename, err);
3278
            av_exit(1);
3279
        }
3280
    } else {
3281
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3282
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3283
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3284

    
3285
        /* disable if no corresponding type found and at least one
3286
           input file */
3287
        if (nb_input_files > 0) {
3288
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3289
                                         &input_has_subtitle);
3290
            if (!input_has_video)
3291
                use_video = 0;
3292
            if (!input_has_audio)
3293
                use_audio = 0;
3294
            if (!input_has_subtitle)
3295
                use_subtitle = 0;
3296
        }
3297

    
3298
        /* manual disable */
3299
        if (audio_disable) {
3300
            use_audio = 0;
3301
        }
3302
        if (video_disable) {
3303
            use_video = 0;
3304
        }
3305
        if (subtitle_disable) {
3306
            use_subtitle = 0;
3307
        }
3308

    
3309
        if (use_video) {
3310
            new_video_stream(oc);
3311
        }
3312

    
3313
        if (use_audio) {
3314
            new_audio_stream(oc);
3315
        }
3316

    
3317
        if (use_subtitle) {
3318
            new_subtitle_stream(oc);
3319
        }
3320

    
3321
        oc->timestamp = rec_timestamp;
3322

    
3323
        for(; metadata_count>0; metadata_count--){
3324
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3325
                                           metadata[metadata_count-1].value);
3326
        }
3327
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3328
    }
3329

    
3330
    output_files[nb_output_files++] = oc;
3331

    
3332
    /* check filename in case of an image number is expected */
3333
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3334
        if (!av_filename_number_test(oc->filename)) {
3335
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3336
            av_exit(1);
3337
        }
3338
    }
3339

    
3340
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3341
        /* test if it already exists to avoid loosing precious files */
3342
        if (!file_overwrite &&
3343
            (strchr(filename, ':') == NULL ||
3344
             filename[1] == ':' ||
3345
             av_strstart(filename, "file:", NULL))) {
3346
            if (url_exist(filename)) {
3347
                int c;
3348

    
3349
                if (!using_stdin) {
3350
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3351
                    fflush(stderr);
3352
                    c = getchar();
3353
                    if (toupper(c) != 'Y') {
3354
                        fprintf(stderr, "Not overwriting - exiting\n");
3355
                        av_exit(1);
3356
                    }
3357
                }
3358
                else {
3359
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3360
                    av_exit(1);
3361
                }
3362
            }
3363
        }
3364

    
3365
        /* open the file */
3366
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3367
            fprintf(stderr, "Could not open '%s'\n", filename);
3368
            av_exit(1);
3369
        }
3370
    }
3371

    
3372
    memset(ap, 0, sizeof(*ap));
3373
    if (av_set_parameters(oc, ap) < 0) {
3374
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3375
                oc->filename);
3376
        av_exit(1);
3377
    }
3378

    
3379
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3380
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3381
    oc->loop_output = loop_output;
3382

    
3383
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3384

    
3385
    /* reset some options */
3386
    file_oformat = NULL;
3387
    file_iformat = NULL;
3388
}
3389

    
3390
/* same option as mencoder */
3391
static void opt_pass(const char *pass_str)
3392
{
3393
    int pass;
3394
    pass = atoi(pass_str);
3395
    if (pass != 1 && pass != 2) {
3396
        fprintf(stderr, "pass number can be only 1 or 2\n");
3397
        av_exit(1);
3398
    }
3399
    do_pass = pass;
3400
}
3401

    
3402
static int64_t getutime(void)
3403
{
3404
#if HAVE_GETRUSAGE
3405
    struct rusage rusage;
3406

    
3407
    getrusage(RUSAGE_SELF, &rusage);
3408
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3409
#elif HAVE_GETPROCESSTIMES
3410
    HANDLE proc;
3411
    FILETIME c, e, k, u;
3412
    proc = GetCurrentProcess();
3413
    GetProcessTimes(proc, &c, &e, &k, &u);
3414
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3415
#else
3416
    return av_gettime();
3417
#endif
3418
}
3419

    
3420
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3421
{
3422
    int i;
3423
    const char *p = str;
3424
    for(i = 0;; i++) {
3425
        dest[i] = atoi(p);
3426
        if(i == 63)
3427
            break;
3428
        p = strchr(p, ',');
3429
        if(!p) {
3430
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3431
            av_exit(1);
3432
        }
3433
        p++;
3434
    }
3435
}
3436

    
3437
static void opt_inter_matrix(const char *arg)
3438
{
3439
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3440
    parse_matrix_coeffs(inter_matrix, arg);
3441
}
3442

    
3443
static void opt_intra_matrix(const char *arg)
3444
{
3445
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3446
    parse_matrix_coeffs(intra_matrix, arg);
3447
}
3448

    
3449
/**
3450
 * Trivial log callback.
3451
 * Only suitable for show_help and similar since it lacks prefix handling.
3452
 */
3453
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3454
{
3455
    vfprintf(stdout, fmt, vl);
3456
}
3457

    
3458
static void show_help(void)
3459
{
3460
    av_log_set_callback(log_callback_help);
3461
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3462
           "Hyper fast Audio and Video encoder\n");
3463
    printf("\n");
3464
    show_help_options(options, "Main options:\n",
3465
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3466
    show_help_options(options, "\nAdvanced options:\n",
3467
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3468
                      OPT_EXPERT);
3469
    show_help_options(options, "\nVideo options:\n",
3470
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3471
                      OPT_VIDEO);
3472
    show_help_options(options, "\nAdvanced Video options:\n",
3473
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3474
                      OPT_VIDEO | OPT_EXPERT);
3475
    show_help_options(options, "\nAudio options:\n",
3476
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3477
                      OPT_AUDIO);
3478
    show_help_options(options, "\nAdvanced Audio options:\n",
3479
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3480
                      OPT_AUDIO | OPT_EXPERT);
3481
    show_help_options(options, "\nSubtitle options:\n",
3482
                      OPT_SUBTITLE | OPT_GRAB,
3483
                      OPT_SUBTITLE);
3484
    show_help_options(options, "\nAudio/Video grab options:\n",
3485
                      OPT_GRAB,
3486
                      OPT_GRAB);
3487
    printf("\n");
3488
    av_opt_show(avctx_opts[0], NULL);
3489
    printf("\n");
3490
    av_opt_show(avformat_opts, NULL);
3491
    printf("\n");
3492
    av_opt_show(sws_opts, NULL);
3493
}
3494

    
3495
static void opt_target(const char *arg)
3496
{
3497
    int norm = -1;
3498
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3499

    
3500
    if(!strncmp(arg, "pal-", 4)) {
3501
        norm = 0;
3502
        arg += 4;
3503
    } else if(!strncmp(arg, "ntsc-", 5)) {
3504
        norm = 1;
3505
        arg += 5;
3506
    } else if(!strncmp(arg, "film-", 5)) {
3507
        norm = 2;
3508
        arg += 5;
3509
    } else {
3510
        int fr;
3511
        /* Calculate FR via float to avoid int overflow */
3512
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3513
        if(fr == 25000) {
3514
            norm = 0;
3515
        } else if((fr == 29970) || (fr == 23976)) {
3516
            norm = 1;
3517
        } else {
3518
            /* Try to determine PAL/NTSC by peeking in the input files */
3519
            if(nb_input_files) {
3520
                int i, j;
3521
                for(j = 0; j < nb_input_files; j++) {
3522
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3523
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3524
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3525
                            continue;
3526
                        fr = c->time_base.den * 1000 / c->time_base.num;
3527
                        if(fr == 25000) {
3528
                            norm = 0;
3529
                            break;
3530
                        } else if((fr == 29970) || (fr == 23976)) {
3531
                            norm = 1;
3532
                            break;
3533
                        }
3534
                    }
3535
                    if(norm >= 0)
3536
                        break;
3537
                }
3538
            }
3539
        }
3540
        if(verbose && norm >= 0)
3541
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3542
    }
3543

    
3544
    if(norm < 0) {
3545
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3546
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3547
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3548
        av_exit(1);
3549
    }
3550

    
3551
    if(!strcmp(arg, "vcd")) {
3552

    
3553
        opt_video_codec("mpeg1video");
3554
        opt_audio_codec("mp2");
3555
        opt_format("vcd");
3556

    
3557
        opt_frame_size(norm ? "352x240" : "352x288");
3558
        opt_frame_rate(NULL, frame_rates[norm]);
3559
        opt_default("gop", norm ? "18" : "15");
3560

    
3561
        opt_default("b", "1150000");
3562
        opt_default("maxrate", "1150000");
3563
        opt_default("minrate", "1150000");
3564
        opt_default("bufsize", "327680"); // 40*1024*8;
3565

    
3566
        opt_default("ab", "224000");
3567
        audio_sample_rate = 44100;
3568
        audio_channels = 2;
3569

    
3570
        opt_default("packetsize", "2324");
3571
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3572

    
3573
        /* We have to offset the PTS, so that it is consistent with the SCR.
3574
           SCR starts at 36000, but the first two packs contain only padding
3575
           and the first pack from the other stream, respectively, may also have
3576
           been written before.
3577
           So the real data starts at SCR 36000+3*1200. */
3578
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3579
    } else if(!strcmp(arg, "svcd")) {
3580

    
3581
        opt_video_codec("mpeg2video");
3582
        opt_audio_codec("mp2");
3583
        opt_format("svcd");
3584

    
3585
        opt_frame_size(norm ? "480x480" : "480x576");
3586
        opt_frame_rate(NULL, frame_rates[norm]);
3587
        opt_default("gop", norm ? "18" : "15");
3588

    
3589
        opt_default("b", "2040000");
3590
        opt_default("maxrate", "2516000");
3591
        opt_default("minrate", "0"); //1145000;
3592
        opt_default("bufsize", "1835008"); //224*1024*8;
3593
        opt_default("flags", "+scan_offset");
3594

    
3595

    
3596
        opt_default("ab", "224000");
3597
        audio_sample_rate = 44100;
3598

    
3599
        opt_default("packetsize", "2324");
3600

    
3601
    } else if(!strcmp(arg, "dvd")) {
3602

    
3603
        opt_video_codec("mpeg2video");
3604
        opt_audio_codec("ac3");
3605
        opt_format("dvd");
3606

    
3607
        opt_frame_size(norm ? "720x480" : "720x576");
3608
        opt_frame_rate(NULL, frame_rates[norm]);
3609
        opt_default("gop", norm ? "18" : "15");
3610

    
3611
        opt_default("b", "6000000");
3612
        opt_default("maxrate", "9000000");
3613
        opt_default("minrate", "0"); //1500000;
3614
        opt_default("bufsize", "1835008"); //224*1024*8;
3615

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

    
3619
        opt_default("ab", "448000");
3620
        audio_sample_rate = 48000;
3621

    
3622
    } else if(!strncmp(arg, "dv", 2)) {
3623

    
3624
        opt_format("dv");
3625

    
3626
        opt_frame_size(norm ? "720x480" : "720x576");
3627
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3628
                                             (norm ? "yuv411p" : "yuv420p"));
3629
        opt_frame_rate(NULL, frame_rates[norm]);
3630

    
3631
        audio_sample_rate = 48000;
3632
        audio_channels = 2;
3633

    
3634
    } else {
3635
        fprintf(stderr, "Unknown target: %s\n", arg);
3636
        av_exit(1);
3637
    }
3638
}
3639

    
3640
static void opt_vstats_file (const char *arg)
3641
{
3642
    av_free (vstats_filename);
3643
    vstats_filename=av_strdup (arg);
3644
}
3645

    
3646
static void opt_vstats (void)
3647
{
3648
    char filename[40];
3649
    time_t today2 = time(NULL);
3650
    struct tm *today = localtime(&today2);
3651

    
3652
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3653
             today->tm_sec);
3654
    opt_vstats_file(filename);
3655
}
3656

    
3657
static int opt_bsf(const char *opt, const char *arg)
3658
{
3659
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3660
    AVBitStreamFilterContext **bsfp;
3661

    
3662
    if(!bsfc){
3663
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3664
        av_exit(1);
3665
    }
3666

    
3667
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3668
          *opt == 'a' ? &audio_bitstream_filters :
3669
                        &subtitle_bitstream_filters;
3670
    while(*bsfp)
3671
        bsfp= &(*bsfp)->next;
3672

    
3673
    *bsfp= bsfc;
3674

    
3675
    return 0;
3676
}
3677

    
3678
static int opt_preset(const char *opt, const char *arg)
3679
{
3680
    FILE *f=NULL;
3681
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3682
    int i;
3683
    const char *base[2]= { getenv("HOME"),
3684
                           FFMPEG_DATADIR,
3685
                         };
3686

    
3687
    for(i=!base[0]; i<2 && !f; i++){
3688
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3689
        f= fopen(filename, "r");
3690
        if(!f){
3691
            char *codec_name= *opt == 'v' ? video_codec_name :
3692
                              *opt == 'a' ? audio_codec_name :
3693
                                            subtitle_codec_name;
3694
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3695
            f= fopen(filename, "r");
3696
        }
3697
    }
3698
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3699
              is_dos_path(arg))){
3700
        av_strlcpy(filename, arg, sizeof(filename));
3701
        f= fopen(filename, "r");
3702
    }
3703

    
3704
    if(!f){
3705
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3706
        av_exit(1);
3707
    }
3708

    
3709
    while(!feof(f)){
3710
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3711
        if(line[0] == '#' && !e)
3712
            continue;
3713
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3714
        if(e){
3715
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3716
            av_exit(1);
3717
        }
3718
        if(!strcmp(tmp, "acodec")){
3719
            opt_audio_codec(tmp2);
3720
        }else if(!strcmp(tmp, "vcodec")){
3721
            opt_video_codec(tmp2);
3722
        }else if(!strcmp(tmp, "scodec")){
3723
            opt_subtitle_codec(tmp2);
3724
        }else if(opt_default(tmp, tmp2) < 0){
3725
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3726
            av_exit(1);
3727
        }
3728
    }
3729

    
3730
    fclose(f);
3731

    
3732
    return 0;
3733
}
3734

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

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

    
3819
    /* audio options */
3820
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3821
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3822
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3823
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3824
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3825
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3826
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3827
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3828
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3829
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3830
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3831
    { "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" },
3832

    
3833
    /* subtitle options */
3834
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3835
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3836
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3837
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3838

    
3839
    /* grab options */
3840
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3841
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3842
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3843

    
3844
    /* muxer options */
3845
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3846
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3847

    
3848
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3849
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3850
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3851

    
3852
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3853
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3854
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3855

    
3856
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3857
    { NULL, },
3858
};
3859

    
3860
int main(int argc, char **argv)
3861
{
3862
    int i;
3863
    int64_t ti;
3864

    
3865
    avcodec_register_all();
3866
    avdevice_register_all();
3867
    av_register_all();
3868

    
3869
    if(isatty(STDIN_FILENO))
3870
        url_set_interrupt_cb(decode_interrupt_cb);
3871

    
3872
    for(i=0; i<CODEC_TYPE_NB; i++){
3873
        avctx_opts[i]= avcodec_alloc_context2(i);
3874
    }
3875
    avformat_opts = avformat_alloc_context();
3876
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3877

    
3878
    show_banner();
3879

    
3880
    /* parse options */
3881
    parse_options(argc, argv, options, opt_output_file);
3882

    
3883
    /* file converter / grab */
3884
    if (nb_output_files <= 0) {
3885
        fprintf(stderr, "At least one output file must be specified\n");
3886
        av_exit(1);
3887
    }
3888

    
3889
    if (nb_input_files == 0) {
3890
        fprintf(stderr, "At least one input file must be specified\n");
3891
        av_exit(1);
3892
    }
3893

    
3894
    ti = getutime();
3895
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3896
                  stream_maps, nb_stream_maps) < 0)
3897
        av_exit(1);
3898
    ti = getutime() - ti;
3899
    if (do_benchmark) {
3900
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3901
    }
3902

    
3903
    return av_exit(0);
3904
}