Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ db4fac64

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 "libavformat/framehook.h"
38
#include "libavcodec/opt.h"
39
#include "libavcodec/audioconvert.h"
40
#include "libavutil/fifo.h"
41
#include "libavutil/avstring.h"
42
#include "libavformat/os_support.h"
43

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

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

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

    
66
#include "cmdutils.h"
67

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

    
71
#undef exit
72

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

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

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

    
90
static const OptionDef options[];
91

    
92
#define MAX_FILES 20
93

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

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

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

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

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

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

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

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

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

    
201
static int rate_emu = 0;
202

    
203
static int  video_channel = 0;
204
static char *video_standard;
205

    
206
static int audio_volume = 256;
207

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

    
223
static int pgmyuv_compatibility_hack=0;
224
static float dts_delta_threshold = 10;
225

    
226
static unsigned int sws_flags = SWS_BICUBIC;
227

    
228
static int64_t timer_start;
229

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

    
235
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
236

    
237
struct AVInputStream;
238

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

    
257
    int video_crop;
258
    int topBand;             /* cropping area sizes */
259
    int leftBand;
260

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

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

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

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

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

    
298
#ifdef HAVE_TERMIOS_H
299

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

    
304
static void term_exit(void)
305
{
306
#ifdef HAVE_TERMIOS_H
307
    tcsetattr (0, TCSANOW, &oldtty);
308
#endif
309
}
310

    
311
static volatile sig_atomic_t received_sigterm = 0;
312

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

    
320
static void term_init(void)
321
{
322
#ifdef HAVE_TERMIOS_H
323
    struct termios tty;
324

    
325
    tcgetattr (0, &tty);
326
    oldtty = tty;
327

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

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

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

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

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

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

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

    
387
static int av_exit(int ret)
388
{
389
    int i;
390

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

    
407
    av_free(intra_matrix);
408
    av_free(inter_matrix);
409

    
410
    if (vstats_file)
411
        fclose(vstats_file);
412
    av_free(vstats_filename);
413

    
414
    av_free(opt_names);
415

    
416
    av_free(video_codec_name);
417
    av_free(audio_codec_name);
418
    av_free(subtitle_codec_name);
419

    
420
    av_free(video_standard);
421

    
422
#ifdef CONFIG_POWERPC_PERF
423
    void powerpc_display_perf_report(void);
424
    powerpc_display_perf_report();
425
#endif /* CONFIG_POWERPC_PERF */
426

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

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

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

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

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

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

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

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

    
473
    if (!nopts)
474
        s->timestamp = av_gettime();
475

    
476
    av_close_input_file(ic);
477
    return 0;
478
}
479

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

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

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

    
509
        bsfc= bsfc->next;
510
    }
511

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

    
519
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
520

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

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

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

    
546
    if (enc->channels != dec->channels)
547
        ost->audio_resample = 1;
548

    
549
    if (ost->audio_resample && !ost->resample) {
550
        if (dec->sample_fmt != SAMPLE_FMT_S16) {
551
            fprintf(stderr, "Audio resampler only works with 16 bits per sample, patch welcome.\n");
552
            av_exit(1);
553
        }
554
        ost->resample = audio_resample_init(enc->channels,    dec->channels,
555
                                            enc->sample_rate, dec->sample_rate);
556
        if (!ost->resample) {
557
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
558
                    dec->channels, dec->sample_rate,
559
                    enc->channels, enc->sample_rate);
560
            av_exit(1);
561
        }
562
    }
563

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

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

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

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

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

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

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

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

    
667
        frame_bytes = enc->frame_size * osize * enc->channels;
668

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

    
673
            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
674

    
675
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
676

    
677
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
678
                                       (short *)audio_buf);
679
            audio_size += ret;
680
            pkt.stream_index= ost->index;
681
            pkt.data= audio_out;
682
            pkt.size= ret;
683
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
684
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
685
            pkt.flags |= PKT_FLAG_KEY;
686
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
687

    
688
            ost->sync_opts += enc->frame_size;
689
        }
690
    } else {
691
        AVPacket pkt;
692
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
693
        av_init_packet(&pkt);
694

    
695
        ost->sync_opts += size_out / (osize * enc->channels);
696

    
697
        /* output a pcm frame */
698
        /* determine the size of the coded buffer */
699
        size_out /= osize;
700
        if (coded_bps)
701
            size_out *= coded_bps;
702

    
703
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
704
        ret = avcodec_encode_audio(enc, audio_out, size_out,
705
                                   (short *)buftmp);
706
        audio_size += ret;
707
        pkt.stream_index= ost->index;
708
        pkt.data= audio_out;
709
        pkt.size= ret;
710
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
711
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
712
        pkt.flags |= PKT_FLAG_KEY;
713
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
714
    }
715
}
716

    
717
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
718
{
719
    AVCodecContext *dec;
720
    AVPicture *picture2;
721
    AVPicture picture_tmp;
722
    uint8_t *buf = 0;
723

    
724
    dec = ist->st->codec;
725

    
726
    /* deinterlace : must be done before any resize */
727
    if (do_deinterlace || using_vhook) {
728
        int size;
729

    
730
        /* create temporary picture */
731
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
732
        buf = av_malloc(size);
733
        if (!buf)
734
            return;
735

    
736
        picture2 = &picture_tmp;
737
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
738

    
739
        if (do_deinterlace){
740
            if(avpicture_deinterlace(picture2, picture,
741
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
742
                /* if error, do not deinterlace */
743
                fprintf(stderr, "Deinterlacing failed\n");
744
                av_free(buf);
745
                buf = NULL;
746
                picture2 = picture;
747
            }
748
        } else {
749
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
750
        }
751
    } else {
752
        picture2 = picture;
753
    }
754

    
755
    if (ENABLE_VHOOK)
756
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
757
                           1000000 * ist->pts / AV_TIME_BASE);
758

    
759
    if (picture != picture2)
760
        *picture = *picture2;
761
    *bufp = buf;
762
}
763

    
764
/* we begin to correct av delay at this threshold */
765
#define AV_DELAY_MAX 0.100
766

    
767
static void do_subtitle_out(AVFormatContext *s,
768
                            AVOutputStream *ost,
769
                            AVInputStream *ist,
770
                            AVSubtitle *sub,
771
                            int64_t pts)
772
{
773
    static uint8_t *subtitle_out = NULL;
774
    int subtitle_out_max_size = 65536;
775
    int subtitle_out_size, nb, i;
776
    AVCodecContext *enc;
777
    AVPacket pkt;
778

    
779
    if (pts == AV_NOPTS_VALUE) {
780
        fprintf(stderr, "Subtitle packets must have a pts\n");
781
        if (exit_on_error)
782
            av_exit(1);
783
        return;
784
    }
785

    
786
    enc = ost->st->codec;
787

    
788
    if (!subtitle_out) {
789
        subtitle_out = av_malloc(subtitle_out_max_size);
790
    }
791

    
792
    /* Note: DVB subtitle need one packet to draw them and one other
793
       packet to clear them */
794
    /* XXX: signal it in the codec context ? */
795
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
796
        nb = 2;
797
    else
798
        nb = 1;
799

    
800
    for(i = 0; i < nb; i++) {
801
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
802
                                                    subtitle_out_max_size, sub);
803

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

    
821
static int bit_buffer_size= 1024*256;
822
static uint8_t *bit_buffer= NULL;
823

    
824
static void do_video_out(AVFormatContext *s,
825
                         AVOutputStream *ost,
826
                         AVInputStream *ist,
827
                         AVFrame *in_picture,
828
                         int *frame_size)
829
{
830
    int nb_frames, i, ret;
831
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
832
    AVFrame picture_crop_temp, picture_pad_temp;
833
    AVCodecContext *enc, *dec;
834

    
835
    avcodec_get_frame_defaults(&picture_crop_temp);
836
    avcodec_get_frame_defaults(&picture_pad_temp);
837

    
838
    enc = ost->st->codec;
839
    dec = ist->st->codec;
840

    
841
    /* by default, we output a single frame */
842
    nb_frames = 1;
843

    
844
    *frame_size = 0;
845

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

    
869
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
870
    if (nb_frames <= 0)
871
        return;
872

    
873
    if (ost->video_crop) {
874
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
875
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
876
            if (exit_on_error)
877
                av_exit(1);
878
            return;
879
        }
880
        formatted_picture = &picture_crop_temp;
881
    } else {
882
        formatted_picture = in_picture;
883
    }
884

    
885
    final_picture = formatted_picture;
886
    padding_src = formatted_picture;
887
    resampling_dst = &ost->pict_tmp;
888
    if (ost->video_pad) {
889
        final_picture = &ost->pict_tmp;
890
        if (ost->video_resample) {
891
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
892
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
893
                if (exit_on_error)
894
                    av_exit(1);
895
                return;
896
            }
897
            resampling_dst = &picture_pad_temp;
898
        }
899
    }
900

    
901
    if (ost->video_resample) {
902
        padding_src = NULL;
903
        final_picture = &ost->pict_tmp;
904
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
905
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
906
    }
907

    
908
    if (ost->video_pad) {
909
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
910
                enc->height, enc->width, enc->pix_fmt,
911
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
912
    }
913

    
914
    /* duplicates frame if needed */
915
    for(i=0;i<nb_frames;i++) {
916
        AVPacket pkt;
917
        av_init_packet(&pkt);
918
        pkt.stream_index= ost->index;
919

    
920
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
921
            /* raw pictures are written as AVPicture structure to
922
               avoid any copies. We support temorarily the older
923
               method. */
924
            AVFrame* old_frame = enc->coded_frame;
925
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
926
            pkt.data= (uint8_t *)final_picture;
927
            pkt.size=  sizeof(AVPicture);
928
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
929
            pkt.flags |= PKT_FLAG_KEY;
930

    
931
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
932
            enc->coded_frame = old_frame;
933
        } else {
934
            AVFrame big_picture;
935

    
936
            big_picture= *final_picture;
937
            /* better than nothing: use input picture interlaced
938
               settings */
939
            big_picture.interlaced_frame = in_picture->interlaced_frame;
940
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
941
                if(top_field_first == -1)
942
                    big_picture.top_field_first = in_picture->top_field_first;
943
                else
944
                    big_picture.top_field_first = top_field_first;
945
            }
946

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

    
976
                if(enc->coded_frame->key_frame)
977
                    pkt.flags |= PKT_FLAG_KEY;
978
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
979
                *frame_size = ret;
980
                video_size += ret;
981
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
982
                //        enc->frame_number-1, enc->real_pict_num, ret,
983
                //        enc->pict_type);
984
                /* if two pass, output log */
985
                if (ost->logfile && enc->stats_out) {
986
                    fprintf(ost->logfile, "%s", enc->stats_out);
987
                }
988
            }
989
        }
990
        ost->sync_opts++;
991
        ost->frame_number++;
992
    }
993
}
994

    
995
static double psnr(double d){
996
    return -10.0*log(d)/log(10.0);
997
}
998

    
999
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1000
                           int frame_size)
1001
{
1002
    AVCodecContext *enc;
1003
    int frame_number;
1004
    double ti1, bitrate, avg_bitrate;
1005

    
1006
    /* this is executed just the first time do_video_stats is called */
1007
    if (!vstats_file) {
1008
        vstats_file = fopen(vstats_filename, "w");
1009
        if (!vstats_file) {
1010
            perror("fopen");
1011
            av_exit(1);
1012
        }
1013
    }
1014

    
1015
    enc = ost->st->codec;
1016
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1017
        frame_number = ost->frame_number;
1018
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1019
        if (enc->flags&CODEC_FLAG_PSNR)
1020
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1021

    
1022
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1023
        /* compute pts value */
1024
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1025
        if (ti1 < 0.01)
1026
            ti1 = 0.01;
1027

    
1028
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1029
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1030
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1031
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1032
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1033
    }
1034
}
1035

    
1036
static void print_report(AVFormatContext **output_files,
1037
                         AVOutputStream **ost_table, int nb_ostreams,
1038
                         int is_last_report)
1039
{
1040
    char buf[1024];
1041
    AVOutputStream *ost;
1042
    AVFormatContext *oc, *os;
1043
    int64_t total_size;
1044
    AVCodecContext *enc;
1045
    int frame_number, vid, i;
1046
    double bitrate, ti1, pts;
1047
    static int64_t last_time = -1;
1048
    static int qp_histogram[52];
1049

    
1050
    if (!is_last_report) {
1051
        int64_t cur_time;
1052
        /* display the report every 0.5 seconds */
1053
        cur_time = av_gettime();
1054
        if (last_time == -1) {
1055
            last_time = cur_time;
1056
            return;
1057
        }
1058
        if ((cur_time - last_time) < 500000)
1059
            return;
1060
        last_time = cur_time;
1061
    }
1062

    
1063

    
1064
    oc = output_files[0];
1065

    
1066
    total_size = url_fsize(oc->pb);
1067
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1068
        total_size= url_ftell(oc->pb);
1069

    
1070
    buf[0] = '\0';
1071
    ti1 = 1e10;
1072
    vid = 0;
1073
    for(i=0;i<nb_ostreams;i++) {
1074
        ost = ost_table[i];
1075
        os = output_files[ost->file_index];
1076
        enc = ost->st->codec;
1077
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1078
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1079
                     !ost->st->stream_copy ?
1080
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1081
        }
1082
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1083
            float t = (av_gettime()-timer_start) / 1000000.0;
1084

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

    
1131
    if (verbose || is_last_report) {
1132
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1133

    
1134
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1135
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1136
            (double)total_size / 1024, ti1, bitrate);
1137

    
1138
        if (verbose > 1)
1139
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1140
                  nb_frames_dup, nb_frames_drop);
1141

    
1142
        if (verbose >= 0)
1143
            fprintf(stderr, "%s    \r", buf);
1144

    
1145
        fflush(stderr);
1146
    }
1147

    
1148
    if (is_last_report && verbose >= 0){
1149
        int64_t raw= audio_size + video_size + extra_size;
1150
        fprintf(stderr, "\n");
1151
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1152
                video_size/1024.0,
1153
                audio_size/1024.0,
1154
                extra_size/1024.0,
1155
                100.0*(total_size - raw)/raw
1156
        );
1157
    }
1158
}
1159

    
1160
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1161
static int output_packet(AVInputStream *ist, int ist_index,
1162
                         AVOutputStream **ost_table, int nb_ostreams,
1163
                         const AVPacket *pkt)
1164
{
1165
    AVFormatContext *os;
1166
    AVOutputStream *ost;
1167
    uint8_t *ptr;
1168
    int len, ret, i;
1169
    uint8_t *data_buf;
1170
    int data_size, got_picture;
1171
    AVFrame picture;
1172
    void *buffer_to_free;
1173
    static unsigned int samples_size= 0;
1174
    static short *samples= NULL;
1175
    AVSubtitle subtitle, *subtitle_to_free;
1176
    int got_subtitle;
1177

    
1178
    if(ist->next_pts == AV_NOPTS_VALUE)
1179
        ist->next_pts= ist->pts;
1180

    
1181
    if (pkt == NULL) {
1182
        /* EOF handling */
1183
        ptr = NULL;
1184
        len = 0;
1185
        goto handle_eof;
1186
    }
1187

    
1188
    if(pkt->dts != AV_NOPTS_VALUE)
1189
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1190

    
1191
    len = pkt->size;
1192
    ptr = pkt->data;
1193

    
1194
    //while we have more to decode or while the decoder did output something on EOF
1195
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1196
    handle_eof:
1197
        ist->pts= ist->next_pts;
1198

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

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

    
1238
                    ret = avcodec_decode_video(ist->st->codec,
1239
                                               &picture, &got_picture, ptr, len);
1240
                    ist->st->quality= picture.quality;
1241
                    if (ret < 0)
1242
                        goto fail_decode;
1243
                    if (!got_picture) {
1244
                        /* no picture yet */
1245
                        goto discard_packet;
1246
                    }
1247
                    if (ist->st->codec->time_base.num != 0) {
1248
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1249
                                          ist->st->codec->time_base.num) /
1250
                            ist->st->codec->time_base.den;
1251
                    }
1252
                    len = 0;
1253
                    break;
1254
            case CODEC_TYPE_SUBTITLE:
1255
                ret = avcodec_decode_subtitle(ist->st->codec,
1256
                                              &subtitle, &got_subtitle, ptr, len);
1257
                if (ret < 0)
1258
                    goto fail_decode;
1259
                if (!got_subtitle) {
1260
                    goto discard_packet;
1261
                }
1262
                subtitle_to_free = &subtitle;
1263
                len = 0;
1264
                break;
1265
            default:
1266
                goto fail_decode;
1267
            }
1268
        } else {
1269
            switch(ist->st->codec->codec_type) {
1270
            case CODEC_TYPE_AUDIO:
1271
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1272
                    ist->st->codec->sample_rate;
1273
                break;
1274
            case CODEC_TYPE_VIDEO:
1275
                if (ist->st->codec->time_base.num != 0) {
1276
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1277
                                      ist->st->codec->time_base.num) /
1278
                        ist->st->codec->time_base.den;
1279
                }
1280
                break;
1281
            }
1282
            data_buf = ptr;
1283
            data_size = len;
1284
            ret = len;
1285
            len = 0;
1286
        }
1287

    
1288
        buffer_to_free = NULL;
1289
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1290
            pre_process_video_frame(ist, (AVPicture *)&picture,
1291
                                    &buffer_to_free);
1292
        }
1293

    
1294
        // preprocess audio (volume)
1295
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1296
            if (audio_volume != 256) {
1297
                short *volp;
1298
                volp = samples;
1299
                for(i=0;i<(data_size / sizeof(short));i++) {
1300
                    int v = ((*volp) * audio_volume + 128) >> 8;
1301
                    if (v < -32768) v = -32768;
1302
                    if (v >  32767) v = 32767;
1303
                    *volp++ = v;
1304
                }
1305
            }
1306
        }
1307

    
1308
        /* frame rate emulation */
1309
        if (rate_emu) {
1310
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1311
            int64_t now = av_gettime() - ist->start;
1312
            if (pts > now)
1313
                usleep(pts - now);
1314
        }
1315

    
1316
        /* if output time reached then transcode raw format,
1317
           encode packets and output them */
1318
        if (start_time == 0 || ist->pts >= start_time)
1319
            for(i=0;i<nb_ostreams;i++) {
1320
                int frame_size;
1321

    
1322
                ost = ost_table[i];
1323
                if (ost->source_index == ist_index) {
1324
                    os = output_files[ost->file_index];
1325

    
1326
#if 0
1327
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1328
                           (double)pkt->pts / AV_TIME_BASE,
1329
                           ((double)ist->pts / AV_TIME_BASE) -
1330
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1331
#endif
1332
                    /* set the input output pts pairs */
1333
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1334

    
1335
                    if (ost->encoding_needed) {
1336
                        switch(ost->st->codec->codec_type) {
1337
                        case CODEC_TYPE_AUDIO:
1338
                            do_audio_out(os, ost, ist, data_buf, data_size);
1339
                            break;
1340
                        case CODEC_TYPE_VIDEO:
1341
                            do_video_out(os, ost, ist, &picture, &frame_size);
1342
                            if (vstats_filename && frame_size)
1343
                                do_video_stats(os, ost, frame_size);
1344
                            break;
1345
                        case CODEC_TYPE_SUBTITLE:
1346
                            do_subtitle_out(os, ost, ist, &subtitle,
1347
                                            pkt->pts);
1348
                            break;
1349
                        default:
1350
                            abort();
1351
                        }
1352
                    } else {
1353
                        AVFrame avframe; //FIXME/XXX remove this
1354
                        AVPacket opkt;
1355
                        av_init_packet(&opkt);
1356

    
1357
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1358
                            continue;
1359

    
1360
                        /* no reencoding needed : output the packet directly */
1361
                        /* force the input stream PTS */
1362

    
1363
                        avcodec_get_frame_defaults(&avframe);
1364
                        ost->st->codec->coded_frame= &avframe;
1365
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1366

    
1367
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1368
                            audio_size += data_size;
1369
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1370
                            video_size += data_size;
1371
                            ost->sync_opts++;
1372
                        }
1373

    
1374
                        opkt.stream_index= ost->index;
1375
                        if(pkt->pts != AV_NOPTS_VALUE)
1376
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1377
                        else
1378
                            opkt.pts= AV_NOPTS_VALUE;
1379

    
1380
                        if (pkt->dts == AV_NOPTS_VALUE)
1381
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1382
                        else
1383
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1384

    
1385
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1386
                        opkt.flags= pkt->flags;
1387

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

    
1392
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1393
                        ost->st->codec->frame_number++;
1394
                        ost->frame_number++;
1395
                        av_free_packet(&opkt);
1396
                    }
1397
                }
1398
            }
1399
        av_free(buffer_to_free);
1400
        /* XXX: allocate the subtitles in the codec ? */
1401
        if (subtitle_to_free) {
1402
            if (subtitle_to_free->rects != NULL) {
1403
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1404
                    av_freep(&subtitle_to_free->rects[i]->bitmap);
1405
                    av_freep(&subtitle_to_free->rects[i]->rgba_palette);
1406
                    av_freep(&subtitle_to_free->rects[i]);
1407
                }
1408
                av_freep(&subtitle_to_free->rects);
1409
            }
1410
            subtitle_to_free->num_rects = 0;
1411
            subtitle_to_free = NULL;
1412
        }
1413
    }
1414
 discard_packet:
1415
    if (pkt == NULL) {
1416
        /* EOF handling */
1417

    
1418
        for(i=0;i<nb_ostreams;i++) {
1419
            ost = ost_table[i];
1420
            if (ost->source_index == ist_index) {
1421
                AVCodecContext *enc= ost->st->codec;
1422
                os = output_files[ost->file_index];
1423

    
1424
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1425
                    continue;
1426
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1427
                    continue;
1428

    
1429
                if (ost->encoding_needed) {
1430
                    for(;;) {
1431
                        AVPacket pkt;
1432
                        int fifo_bytes;
1433
                        av_init_packet(&pkt);
1434
                        pkt.stream_index= ost->index;
1435

    
1436
                        switch(ost->st->codec->codec_type) {
1437
                        case CODEC_TYPE_AUDIO:
1438
                            fifo_bytes = av_fifo_size(&ost->fifo);
1439
                            ret = 0;
1440
                            /* encode any samples remaining in fifo */
1441
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1442
                                int fs_tmp = enc->frame_size;
1443
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1444
                                av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1445
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1446
                                enc->frame_size = fs_tmp;
1447
                            }
1448
                            if(ret <= 0) {
1449
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1450
                            }
1451
                            audio_size += ret;
1452
                            pkt.flags |= PKT_FLAG_KEY;
1453
                            break;
1454
                        case CODEC_TYPE_VIDEO:
1455
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1456
                            video_size += ret;
1457
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1458
                                pkt.flags |= PKT_FLAG_KEY;
1459
                            if (ost->logfile && enc->stats_out) {
1460
                                fprintf(ost->logfile, "%s", enc->stats_out);
1461
                            }
1462
                            break;
1463
                        default:
1464
                            ret=-1;
1465
                        }
1466

    
1467
                        if(ret<=0)
1468
                            break;
1469
                        pkt.data= bit_buffer;
1470
                        pkt.size= ret;
1471
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1472
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1473
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1474
                    }
1475
                }
1476
            }
1477
        }
1478
    }
1479

    
1480
    return 0;
1481
 fail_decode:
1482
    return -1;
1483
}
1484

    
1485
static void print_sdp(AVFormatContext **avc, int n)
1486
{
1487
    char sdp[2048];
1488

    
1489
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1490
    printf("SDP:\n%s\n", sdp);
1491
    fflush(stdout);
1492
}
1493

    
1494
static int stream_index_from_inputs(AVFormatContext **input_files,
1495
                                    int nb_input_files,
1496
                                    AVInputFile *file_table,
1497
                                    AVInputStream **ist_table,
1498
                                    enum CodecType type,
1499
                                    int programid)
1500
{
1501
    int p, q, z;
1502
    for(z=0; z<nb_input_files; z++) {
1503
        AVFormatContext *ic = input_files[z];
1504
        for(p=0; p<ic->nb_programs; p++) {
1505
            AVProgram *program = ic->programs[p];
1506
            if(program->id != programid)
1507
                continue;
1508
            for(q=0; q<program->nb_stream_indexes; q++) {
1509
                int sidx = program->stream_index[q];
1510
                int ris = file_table[z].ist_index + sidx;
1511
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1512
                    return ris;
1513
            }
1514
        }
1515
    }
1516

    
1517
    return -1;
1518
}
1519

    
1520
/*
1521
 * The following code is the main loop of the file converter
1522
 */
1523
static int av_encode(AVFormatContext **output_files,
1524
                     int nb_output_files,
1525
                     AVFormatContext **input_files,
1526
                     int nb_input_files,
1527
                     AVStreamMap *stream_maps, int nb_stream_maps)
1528
{
1529
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1530
    AVFormatContext *is, *os;
1531
    AVCodecContext *codec, *icodec;
1532
    AVOutputStream *ost, **ost_table = NULL;
1533
    AVInputStream *ist, **ist_table = NULL;
1534
    AVInputFile *file_table;
1535
    int key;
1536
    int want_sdp = 1;
1537

    
1538
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1539
    if (!file_table)
1540
        goto fail;
1541

    
1542
    /* input stream init */
1543
    j = 0;
1544
    for(i=0;i<nb_input_files;i++) {
1545
        is = input_files[i];
1546
        file_table[i].ist_index = j;
1547
        file_table[i].nb_streams = is->nb_streams;
1548
        j += is->nb_streams;
1549
    }
1550
    nb_istreams = j;
1551

    
1552
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1553
    if (!ist_table)
1554
        goto fail;
1555

    
1556
    for(i=0;i<nb_istreams;i++) {
1557
        ist = av_mallocz(sizeof(AVInputStream));
1558
        if (!ist)
1559
            goto fail;
1560
        ist_table[i] = ist;
1561
    }
1562
    j = 0;
1563
    for(i=0;i<nb_input_files;i++) {
1564
        is = input_files[i];
1565
        for(k=0;k<is->nb_streams;k++) {
1566
            ist = ist_table[j++];
1567
            ist->st = is->streams[k];
1568
            ist->file_index = i;
1569
            ist->index = k;
1570
            ist->discard = 1; /* the stream is discarded by default
1571
                                 (changed later) */
1572

    
1573
            if (rate_emu) {
1574
                ist->start = av_gettime();
1575
            }
1576
        }
1577
    }
1578

    
1579
    /* output stream init */
1580
    nb_ostreams = 0;
1581
    for(i=0;i<nb_output_files;i++) {
1582
        os = output_files[i];
1583
        if (!os->nb_streams) {
1584
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1585
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1586
            av_exit(1);
1587
        }
1588
        nb_ostreams += os->nb_streams;
1589
    }
1590
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1591
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1592
        av_exit(1);
1593
    }
1594

    
1595
    /* Sanity check the mapping args -- do the input files & streams exist? */
1596
    for(i=0;i<nb_stream_maps;i++) {
1597
        int fi = stream_maps[i].file_index;
1598
        int si = stream_maps[i].stream_index;
1599

    
1600
        if (fi < 0 || fi > nb_input_files - 1 ||
1601
            si < 0 || si > file_table[fi].nb_streams - 1) {
1602
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1603
            av_exit(1);
1604
        }
1605
        fi = stream_maps[i].sync_file_index;
1606
        si = stream_maps[i].sync_stream_index;
1607
        if (fi < 0 || fi > nb_input_files - 1 ||
1608
            si < 0 || si > file_table[fi].nb_streams - 1) {
1609
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1610
            av_exit(1);
1611
        }
1612
    }
1613

    
1614
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1615
    if (!ost_table)
1616
        goto fail;
1617
    for(i=0;i<nb_ostreams;i++) {
1618
        ost = av_mallocz(sizeof(AVOutputStream));
1619
        if (!ost)
1620
            goto fail;
1621
        ost_table[i] = ost;
1622
    }
1623

    
1624
    n = 0;
1625
    for(k=0;k<nb_output_files;k++) {
1626
        os = output_files[k];
1627
        for(i=0;i<os->nb_streams;i++,n++) {
1628
            int found;
1629
            ost = ost_table[n];
1630
            ost->file_index = k;
1631
            ost->index = i;
1632
            ost->st = os->streams[i];
1633
            if (nb_stream_maps > 0) {
1634
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1635
                    stream_maps[n].stream_index;
1636

    
1637
                /* Sanity check that the stream types match */
1638
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1639
                    int i= ost->file_index;
1640
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1641
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1642
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1643
                        ost->file_index, ost->index);
1644
                    av_exit(1);
1645
                }
1646

    
1647
            } else {
1648
                if(opt_programid) {
1649
                    found = 0;
1650
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1651
                    if(j != -1) {
1652
                        ost->source_index = j;
1653
                        found = 1;
1654
                    }
1655
                } else {
1656
                    /* get corresponding input stream index : we select the first one with the right type */
1657
                    found = 0;
1658
                    for(j=0;j<nb_istreams;j++) {
1659
                        ist = ist_table[j];
1660
                        if (ist->discard &&
1661
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1662
                            ost->source_index = j;
1663
                            found = 1;
1664
                            break;
1665
                        }
1666
                    }
1667
                }
1668

    
1669
                if (!found) {
1670
                    if(! opt_programid) {
1671
                        /* try again and reuse existing stream */
1672
                        for(j=0;j<nb_istreams;j++) {
1673
                            ist = ist_table[j];
1674
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1675
                                ost->source_index = j;
1676
                                found = 1;
1677
                            }
1678
                        }
1679
                    }
1680
                    if (!found) {
1681
                        int i= ost->file_index;
1682
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1683
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1684
                                ost->file_index, ost->index);
1685
                        av_exit(1);
1686
                    }
1687
                }
1688
            }
1689
            ist = ist_table[ost->source_index];
1690
            ist->discard = 0;
1691
            ost->sync_ist = (nb_stream_maps > 0) ?
1692
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1693
                         stream_maps[n].sync_stream_index] : ist;
1694
        }
1695
    }
1696

    
1697
    /* for each output stream, we compute the right encoding parameters */
1698
    for(i=0;i<nb_ostreams;i++) {
1699
        ost = ost_table[i];
1700
        os = output_files[ost->file_index];
1701
        ist = ist_table[ost->source_index];
1702

    
1703
        codec = ost->st->codec;
1704
        icodec = ist->st->codec;
1705

    
1706
        if (!ost->st->language[0])
1707
            av_strlcpy(ost->st->language, ist->st->language,
1708
                       sizeof(ost->st->language));
1709

    
1710
        ost->st->disposition = ist->st->disposition;
1711

    
1712
        if (ost->st->stream_copy) {
1713
            /* if stream_copy is selected, no need to decode or encode */
1714
            codec->codec_id = icodec->codec_id;
1715
            codec->codec_type = icodec->codec_type;
1716

    
1717
            if(!codec->codec_tag){
1718
                if(   !os->oformat->codec_tag
1719
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1720
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1721
                    codec->codec_tag = icodec->codec_tag;
1722
            }
1723

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

    
1840
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1841
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1842
                         i);
1843
                if (codec->flags & CODEC_FLAG_PASS1) {
1844
                    f = fopen(logfilename, "w");
1845
                    if (!f) {
1846
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1847
                        av_exit(1);
1848
                    }
1849
                    ost->logfile = f;
1850
                } else {
1851
                    /* read the log file */
1852
                    f = fopen(logfilename, "r");
1853
                    if (!f) {
1854
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1855
                        av_exit(1);
1856
                    }
1857
                    fseek(f, 0, SEEK_END);
1858
                    size = ftell(f);
1859
                    fseek(f, 0, SEEK_SET);
1860
                    logbuffer = av_malloc(size + 1);
1861
                    if (!logbuffer) {
1862
                        fprintf(stderr, "Could not allocate log buffer\n");
1863
                        av_exit(1);
1864
                    }
1865
                    size = fread(logbuffer, 1, size, f);
1866
                    fclose(f);
1867
                    logbuffer[size] = '\0';
1868
                    codec->stats_in = logbuffer;
1869
                }
1870
            }
1871
        }
1872
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1873
            int size= codec->width * codec->height;
1874
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1875
        }
1876
    }
1877

    
1878
    if (!bit_buffer)
1879
        bit_buffer = av_malloc(bit_buffer_size);
1880
    if (!bit_buffer)
1881
        goto fail;
1882

    
1883
    /* dump the file output parameters - cannot be done before in case
1884
       of stream copy */
1885
    for(i=0;i<nb_output_files;i++) {
1886
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1887
    }
1888

    
1889
    /* dump the stream mapping */
1890
    if (verbose >= 0) {
1891
        fprintf(stderr, "Stream mapping:\n");
1892
        for(i=0;i<nb_ostreams;i++) {
1893
            ost = ost_table[i];
1894
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1895
                    ist_table[ost->source_index]->file_index,
1896
                    ist_table[ost->source_index]->index,
1897
                    ost->file_index,
1898
                    ost->index);
1899
            if (ost->sync_ist != ist_table[ost->source_index])
1900
                fprintf(stderr, " [sync #%d.%d]",
1901
                        ost->sync_ist->file_index,
1902
                        ost->sync_ist->index);
1903
            fprintf(stderr, "\n");
1904
        }
1905
    }
1906

    
1907
    /* open each encoder */
1908
    for(i=0;i<nb_ostreams;i++) {
1909
        ost = ost_table[i];
1910
        if (ost->encoding_needed) {
1911
            AVCodec *codec = output_codecs[i];
1912
            if (!codec)
1913
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
1914
            if (!codec) {
1915
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1916
                        ost->file_index, ost->index);
1917
                av_exit(1);
1918
            }
1919
            if (avcodec_open(ost->st->codec, codec) < 0) {
1920
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1921
                        ost->file_index, ost->index);
1922
                av_exit(1);
1923
            }
1924
            extra_size += ost->st->codec->extradata_size;
1925
        }
1926
    }
1927

    
1928
    /* open each decoder */
1929
    for(i=0;i<nb_istreams;i++) {
1930
        ist = ist_table[i];
1931
        if (ist->decoding_needed) {
1932
            AVCodec *codec = input_codecs[i];
1933
            if (!codec)
1934
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
1935
            if (!codec) {
1936
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1937
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1938
                av_exit(1);
1939
            }
1940
            if (avcodec_open(ist->st->codec, codec) < 0) {
1941
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1942
                        ist->file_index, ist->index);
1943
                av_exit(1);
1944
            }
1945
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1946
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1947
        }
1948
    }
1949

    
1950
    /* init pts */
1951
    for(i=0;i<nb_istreams;i++) {
1952
        ist = ist_table[i];
1953
        is = input_files[ist->file_index];
1954
        ist->pts = 0;
1955
        ist->next_pts = AV_NOPTS_VALUE;
1956
        ist->is_start = 1;
1957
    }
1958

    
1959
    /* set meta data information from input file if required */
1960
    for (i=0;i<nb_meta_data_maps;i++) {
1961
        AVFormatContext *out_file;
1962
        AVFormatContext *in_file;
1963

    
1964
        int out_file_index = meta_data_maps[i].out_file;
1965
        int in_file_index = meta_data_maps[i].in_file;
1966
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1967
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1968
            ret = AVERROR(EINVAL);
1969
            goto fail;
1970
        }
1971
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1972
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1973
            ret = AVERROR(EINVAL);
1974
            goto fail;
1975
        }
1976

    
1977
        out_file = output_files[out_file_index];
1978
        in_file = input_files[in_file_index];
1979

    
1980
        strcpy(out_file->title, in_file->title);
1981
        strcpy(out_file->author, in_file->author);
1982
        strcpy(out_file->copyright, in_file->copyright);
1983
        strcpy(out_file->comment, in_file->comment);
1984
        strcpy(out_file->album, in_file->album);
1985
        out_file->year = in_file->year;
1986
        out_file->track = in_file->track;
1987
        strcpy(out_file->genre, in_file->genre);
1988
    }
1989

    
1990
    /* open files and write file headers */
1991
    for(i=0;i<nb_output_files;i++) {
1992
        os = output_files[i];
1993
        if (av_write_header(os) < 0) {
1994
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1995
            ret = AVERROR(EINVAL);
1996
            goto fail;
1997
        }
1998
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
1999
            want_sdp = 0;
2000
        }
2001
    }
2002
    if (want_sdp) {
2003
        print_sdp(output_files, nb_output_files);
2004
    }
2005

    
2006
    if (!using_stdin && verbose >= 0) {
2007
        fprintf(stderr, "Press [q] to stop encoding\n");
2008
        url_set_interrupt_cb(decode_interrupt_cb);
2009
    }
2010
    term_init();
2011

    
2012
    key = -1;
2013
    timer_start = av_gettime();
2014

    
2015
    for(; received_sigterm == 0;) {
2016
        int file_index, ist_index;
2017
        AVPacket pkt;
2018
        double ipts_min;
2019
        double opts_min;
2020

    
2021
    redo:
2022
        ipts_min= 1e100;
2023
        opts_min= 1e100;
2024
        /* if 'q' pressed, exits */
2025
        if (!using_stdin) {
2026
            if (q_pressed)
2027
                break;
2028
            /* read_key() returns 0 on EOF */
2029
            key = read_key();
2030
            if (key == 'q')
2031
                break;
2032
        }
2033

    
2034
        /* select the stream that we must read now by looking at the
2035
           smallest output pts */
2036
        file_index = -1;
2037
        for(i=0;i<nb_ostreams;i++) {
2038
            double ipts, opts;
2039
            ost = ost_table[i];
2040
            os = output_files[ost->file_index];
2041
            ist = ist_table[ost->source_index];
2042
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2043
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2044
            else
2045
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2046
            ipts = (double)ist->pts;
2047
            if (!file_table[ist->file_index].eof_reached){
2048
                if(ipts < ipts_min) {
2049
                    ipts_min = ipts;
2050
                    if(input_sync ) file_index = ist->file_index;
2051
                }
2052
                if(opts < opts_min) {
2053
                    opts_min = opts;
2054
                    if(!input_sync) file_index = ist->file_index;
2055
                }
2056
            }
2057
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2058
                file_index= -1;
2059
                break;
2060
            }
2061
        }
2062
        /* if none, if is finished */
2063
        if (file_index < 0) {
2064
            break;
2065
        }
2066

    
2067
        /* finish if recording time exhausted */
2068
        if (opts_min >= (recording_time / 1000000.0))
2069
            break;
2070

    
2071
        /* finish if limit size exhausted */
2072
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2073
            break;
2074

    
2075
        /* read a frame from it and output it in the fifo */
2076
        is = input_files[file_index];
2077
        if (av_read_frame(is, &pkt) < 0) {
2078
            file_table[file_index].eof_reached = 1;
2079
            if (opt_shortest)
2080
                break;
2081
            else
2082
                continue;
2083
        }
2084

    
2085
        if (do_pkt_dump) {
2086
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2087
        }
2088
        /* the following test is needed in case new streams appear
2089
           dynamically in stream : we ignore them */
2090
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2091
            goto discard_packet;
2092
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2093
        ist = ist_table[ist_index];
2094
        if (ist->discard)
2095
            goto discard_packet;
2096

    
2097
        if (pkt.dts != AV_NOPTS_VALUE)
2098
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2099
        if (pkt.pts != AV_NOPTS_VALUE)
2100
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2101

    
2102
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2103
            if(pkt.pts != AV_NOPTS_VALUE)
2104
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2105
            if(pkt.dts != AV_NOPTS_VALUE)
2106
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2107
        }
2108

    
2109
//        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);
2110
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2111
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2112
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2113
            int64_t delta= pkt_dts - ist->next_pts;
2114
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2115
                input_files_ts_offset[ist->file_index]-= delta;
2116
                if (verbose > 2)
2117
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2118
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2119
                if(pkt.pts != AV_NOPTS_VALUE)
2120
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2121
            }
2122
        }
2123

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

    
2127
            if (verbose >= 0)
2128
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2129
                        ist->file_index, ist->index);
2130
            if (exit_on_error)
2131
                av_exit(1);
2132
            av_free_packet(&pkt);
2133
            goto redo;
2134
        }
2135

    
2136
    discard_packet:
2137
        av_free_packet(&pkt);
2138

    
2139
        /* dump report by using the output first video and audio streams */
2140
        print_report(output_files, ost_table, nb_ostreams, 0);
2141
    }
2142

    
2143
    /* at the end of stream, we must flush the decoder buffers */
2144
    for(i=0;i<nb_istreams;i++) {
2145
        ist = ist_table[i];
2146
        if (ist->decoding_needed) {
2147
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2148
        }
2149
    }
2150

    
2151
    term_exit();
2152

    
2153
    /* write the trailer if needed and close file */
2154
    for(i=0;i<nb_output_files;i++) {
2155
        os = output_files[i];
2156
        av_write_trailer(os);
2157
    }
2158

    
2159
    /* dump report by using the first video and audio streams */
2160
    print_report(output_files, ost_table, nb_ostreams, 1);
2161

    
2162
    /* close each encoder */
2163
    for(i=0;i<nb_ostreams;i++) {
2164
        ost = ost_table[i];
2165
        if (ost->encoding_needed) {
2166
            av_freep(&ost->st->codec->stats_in);
2167
            avcodec_close(ost->st->codec);
2168
        }
2169
    }
2170

    
2171
    /* close each decoder */
2172
    for(i=0;i<nb_istreams;i++) {
2173
        ist = ist_table[i];
2174
        if (ist->decoding_needed) {
2175
            avcodec_close(ist->st->codec);
2176
        }
2177
    }
2178

    
2179
    /* finished ! */
2180

    
2181
    ret = 0;
2182
 fail1:
2183
    av_freep(&bit_buffer);
2184
    av_free(file_table);
2185

    
2186
    if (ist_table) {
2187
        for(i=0;i<nb_istreams;i++) {
2188
            ist = ist_table[i];
2189
            av_free(ist);
2190
        }
2191
        av_free(ist_table);
2192
    }
2193
    if (ost_table) {
2194
        for(i=0;i<nb_ostreams;i++) {
2195
            ost = ost_table[i];
2196
            if (ost) {
2197
                if (ost->logfile) {
2198
                    fclose(ost->logfile);
2199
                    ost->logfile = NULL;
2200
                }
2201
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2202
                                             initialized but set to zero */
2203
                av_free(ost->pict_tmp.data[0]);
2204
                if (ost->video_resample)
2205
                    sws_freeContext(ost->img_resample_ctx);
2206
                if (ost->resample)
2207
                    audio_resample_close(ost->resample);
2208
                if (ost->reformat_ctx)
2209
                    av_audio_convert_free(ost->reformat_ctx);
2210
                av_free(ost);
2211
            }
2212
        }
2213
        av_free(ost_table);
2214
    }
2215
    return ret;
2216
 fail:
2217
    ret = AVERROR(ENOMEM);
2218
    goto fail1;
2219
}
2220

    
2221
#if 0
2222
int file_read(const char *filename)
2223
{
2224
    URLContext *h;
2225
    unsigned char buffer[1024];
2226
    int len, i;
2227

2228
    if (url_open(&h, filename, O_RDONLY) < 0) {
2229
        printf("could not open '%s'\n", filename);
2230
        return -1;
2231
    }
2232
    for(;;) {
2233
        len = url_read(h, buffer, sizeof(buffer));
2234
        if (len <= 0)
2235
            break;
2236
        for(i=0;i<len;i++) putchar(buffer[i]);
2237
    }
2238
    url_close(h);
2239
    return 0;
2240
}
2241
#endif
2242

    
2243
static void opt_format(const char *arg)
2244
{
2245
    /* compatibility stuff for pgmyuv */
2246
    if (!strcmp(arg, "pgmyuv")) {
2247
        pgmyuv_compatibility_hack=1;
2248
//        opt_image_format(arg);
2249
        arg = "image2";
2250
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2251
    }
2252

    
2253
    file_iformat = av_find_input_format(arg);
2254
    file_oformat = guess_format(arg, NULL, NULL);
2255
    if (!file_iformat && !file_oformat) {
2256
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2257
        av_exit(1);
2258
    }
2259
}
2260

    
2261
static void opt_video_rc_override_string(const char *arg)
2262
{
2263
    video_rc_override_string = arg;
2264
}
2265

    
2266
static int opt_me_threshold(const char *opt, const char *arg)
2267
{
2268
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2269
    return 0;
2270
}
2271

    
2272
static int opt_verbose(const char *opt, const char *arg)
2273
{
2274
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2275
    av_log_set_level(verbose);
2276
    return 0;
2277
}
2278

    
2279
static int opt_frame_rate(const char *opt, const char *arg)
2280
{
2281
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2282
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2283
        av_exit(1);
2284
    }
2285
    return 0;
2286
}
2287

    
2288
static int opt_bitrate(const char *opt, const char *arg)
2289
{
2290
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2291

    
2292
    opt_default(opt, arg);
2293

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

    
2297
    return 0;
2298
}
2299

    
2300
static void opt_frame_crop_top(const char *arg)
2301
{
2302
    frame_topBand = atoi(arg);
2303
    if (frame_topBand < 0) {
2304
        fprintf(stderr, "Incorrect top crop size\n");
2305
        av_exit(1);
2306
    }
2307
    if ((frame_topBand % 2) != 0) {
2308
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2309
        av_exit(1);
2310
    }
2311
    if ((frame_topBand) >= frame_height){
2312
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2313
        av_exit(1);
2314
    }
2315
    frame_height -= frame_topBand;
2316
}
2317

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

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

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

    
2372
static void opt_frame_size(const char *arg)
2373
{
2374
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2375
        fprintf(stderr, "Incorrect frame size\n");
2376
        av_exit(1);
2377
    }
2378
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2379
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2380
        av_exit(1);
2381
    }
2382
}
2383

    
2384

    
2385
#define SCALEBITS 10
2386
#define ONE_HALF  (1 << (SCALEBITS - 1))
2387
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2388

    
2389
#define RGB_TO_Y(r, g, b) \
2390
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2391
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2392

    
2393
#define RGB_TO_U(r1, g1, b1, shift)\
2394
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2395
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2396

    
2397
#define RGB_TO_V(r1, g1, b1, shift)\
2398
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2399
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2400

    
2401
static void opt_pad_color(const char *arg) {
2402
    /* Input is expected to be six hex digits similar to
2403
       how colors are expressed in html tags (but without the #) */
2404
    int rgb = strtol(arg, NULL, 16);
2405
    int r,g,b;
2406

    
2407
    r = (rgb >> 16);
2408
    g = ((rgb >> 8) & 255);
2409
    b = (rgb & 255);
2410

    
2411
    padcolor[0] = RGB_TO_Y(r,g,b);
2412
    padcolor[1] = RGB_TO_U(r,g,b,0);
2413
    padcolor[2] = RGB_TO_V(r,g,b,0);
2414
}
2415

    
2416
static void opt_frame_pad_top(const char *arg)
2417
{
2418
    frame_padtop = atoi(arg);
2419
    if (frame_padtop < 0) {
2420
        fprintf(stderr, "Incorrect top pad size\n");
2421
        av_exit(1);
2422
    }
2423
    if ((frame_padtop % 2) != 0) {
2424
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2425
        av_exit(1);
2426
    }
2427
}
2428

    
2429
static void opt_frame_pad_bottom(const char *arg)
2430
{
2431
    frame_padbottom = atoi(arg);
2432
    if (frame_padbottom < 0) {
2433
        fprintf(stderr, "Incorrect bottom pad size\n");
2434
        av_exit(1);
2435
    }
2436
    if ((frame_padbottom % 2) != 0) {
2437
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2438
        av_exit(1);
2439
    }
2440
}
2441

    
2442

    
2443
static void opt_frame_pad_left(const char *arg)
2444
{
2445
    frame_padleft = atoi(arg);
2446
    if (frame_padleft < 0) {
2447
        fprintf(stderr, "Incorrect left pad size\n");
2448
        av_exit(1);
2449
    }
2450
    if ((frame_padleft % 2) != 0) {
2451
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2452
        av_exit(1);
2453
    }
2454
}
2455

    
2456

    
2457
static void opt_frame_pad_right(const char *arg)
2458
{
2459
    frame_padright = atoi(arg);
2460
    if (frame_padright < 0) {
2461
        fprintf(stderr, "Incorrect right pad size\n");
2462
        av_exit(1);
2463
    }
2464
    if ((frame_padright % 2) != 0) {
2465
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2466
        av_exit(1);
2467
    }
2468
}
2469

    
2470
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2471
{
2472
    int i;
2473
    char fmt_str[128];
2474
    for (i=-1; i < nb_fmts; i++) {
2475
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2476
        fprintf(stdout, "%s\n", fmt_str);
2477
    }
2478
}
2479

    
2480
static void opt_frame_pix_fmt(const char *arg)
2481
{
2482
    if (strcmp(arg, "list"))
2483
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2484
    else {
2485
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2486
        av_exit(0);
2487
    }
2488
}
2489

    
2490
static void opt_frame_aspect_ratio(const char *arg)
2491
{
2492
    int x = 0, y = 0;
2493
    double ar = 0;
2494
    const char *p;
2495
    char *end;
2496

    
2497
    p = strchr(arg, ':');
2498
    if (p) {
2499
        x = strtol(arg, &end, 10);
2500
        if (end == p)
2501
            y = strtol(end+1, &end, 10);
2502
        if (x > 0 && y > 0)
2503
            ar = (double)x / (double)y;
2504
    } else
2505
        ar = strtod(arg, NULL);
2506

    
2507
    if (!ar) {
2508
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2509
        av_exit(1);
2510
    }
2511
    frame_aspect_ratio = ar;
2512
}
2513

    
2514
static void opt_qscale(const char *arg)
2515
{
2516
    video_qscale = atof(arg);
2517
    if (video_qscale <= 0 ||
2518
        video_qscale > 255) {
2519
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2520
        av_exit(1);
2521
    }
2522
}
2523

    
2524
static void opt_top_field_first(const char *arg)
2525
{
2526
    top_field_first= atoi(arg);
2527
}
2528

    
2529
static int opt_thread_count(const char *opt, const char *arg)
2530
{
2531
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2532
#if !defined(HAVE_THREADS)
2533
    if (verbose >= 0)
2534
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2535
#endif
2536
    return 0;
2537
}
2538

    
2539
static void opt_audio_sample_fmt(const char *arg)
2540
{
2541
    if (strcmp(arg, "list"))
2542
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2543
    else {
2544
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2545
        av_exit(0);
2546
    }
2547
}
2548

    
2549
static int opt_audio_rate(const char *opt, const char *arg)
2550
{
2551
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2552
    return 0;
2553
}
2554

    
2555
static int opt_audio_channels(const char *opt, const char *arg)
2556
{
2557
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2558
    return 0;
2559
}
2560

    
2561
static void opt_video_channel(const char *arg)
2562
{
2563
    video_channel = strtol(arg, NULL, 0);
2564
}
2565

    
2566
static void opt_video_standard(const char *arg)
2567
{
2568
    video_standard = av_strdup(arg);
2569
}
2570

    
2571
static void opt_codec(int *pstream_copy, char **pcodec_name,
2572
                      int codec_type, const char *arg)
2573
{
2574
    av_freep(pcodec_name);
2575
    if (!strcmp(arg, "copy")) {
2576
        *pstream_copy = 1;
2577
    } else {
2578
        *pcodec_name = av_strdup(arg);
2579
    }
2580
}
2581

    
2582
static void opt_audio_codec(const char *arg)
2583
{
2584
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2585
}
2586

    
2587
static void opt_audio_tag(const char *arg)
2588
{
2589
    char *tail;
2590
    audio_codec_tag= strtol(arg, &tail, 0);
2591

    
2592
    if(!tail || *tail)
2593
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2594
}
2595

    
2596
static void opt_video_tag(const char *arg)
2597
{
2598
    char *tail;
2599
    video_codec_tag= strtol(arg, &tail, 0);
2600

    
2601
    if(!tail || *tail)
2602
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2603
}
2604

    
2605
#ifdef CONFIG_VHOOK
2606
static void add_frame_hooker(const char *arg)
2607
{
2608
    int argc = 0;
2609
    char *argv[64];
2610
    int i;
2611
    char *args = av_strdup(arg);
2612

    
2613
    using_vhook = 1;
2614

    
2615
    argv[0] = strtok(args, " ");
2616
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2617
    }
2618

    
2619
    i = frame_hook_add(argc, argv);
2620

    
2621
    if (i != 0) {
2622
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2623
        av_exit(1);
2624
    }
2625
}
2626
#endif
2627

    
2628
static void opt_video_codec(const char *arg)
2629
{
2630
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2631
}
2632

    
2633
static void opt_subtitle_codec(const char *arg)
2634
{
2635
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2636
}
2637

    
2638
static void opt_map(const char *arg)
2639
{
2640
    AVStreamMap *m;
2641
    char *p;
2642

    
2643
    m = &stream_maps[nb_stream_maps++];
2644

    
2645
    m->file_index = strtol(arg, &p, 0);
2646
    if (*p)
2647
        p++;
2648

    
2649
    m->stream_index = strtol(p, &p, 0);
2650
    if (*p) {
2651
        p++;
2652
        m->sync_file_index = strtol(p, &p, 0);
2653
        if (*p)
2654
            p++;
2655
        m->sync_stream_index = strtol(p, &p, 0);
2656
    } else {
2657
        m->sync_file_index = m->file_index;
2658
        m->sync_stream_index = m->stream_index;
2659
    }
2660
}
2661

    
2662
static void opt_map_meta_data(const char *arg)
2663
{
2664
    AVMetaDataMap *m;
2665
    char *p;
2666

    
2667
    m = &meta_data_maps[nb_meta_data_maps++];
2668

    
2669
    m->out_file = strtol(arg, &p, 0);
2670
    if (*p)
2671
        p++;
2672

    
2673
    m->in_file = strtol(p, &p, 0);
2674
}
2675

    
2676
static void opt_input_ts_scale(const char *arg)
2677
{
2678
    unsigned int stream;
2679
    double scale;
2680
    char *p;
2681

    
2682
    stream = strtol(arg, &p, 0);
2683
    if (*p)
2684
        p++;
2685
    scale= strtod(p, &p);
2686

    
2687
    if(stream >= MAX_STREAMS)
2688
        av_exit(1);
2689

    
2690
    input_files_ts_scale[nb_input_files][stream]= scale;
2691
}
2692

    
2693
static int opt_recording_time(const char *opt, const char *arg)
2694
{
2695
    recording_time = parse_time_or_die(opt, arg, 1);
2696
    return 0;
2697
}
2698

    
2699
static int opt_start_time(const char *opt, const char *arg)
2700
{
2701
    start_time = parse_time_or_die(opt, arg, 1);
2702
    return 0;
2703
}
2704

    
2705
static int opt_rec_timestamp(const char *opt, const char *arg)
2706
{
2707
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2708
    return 0;
2709
}
2710

    
2711
static int opt_input_ts_offset(const char *opt, const char *arg)
2712
{
2713
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2714
    return 0;
2715
}
2716

    
2717
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2718
{
2719
    const char *codec_string = encoder ? "encoder" : "decoder";
2720
    AVCodec *codec;
2721

    
2722
    if(!name)
2723
        return CODEC_ID_NONE;
2724
    codec = encoder ?
2725
        avcodec_find_encoder_by_name(name) :
2726
        avcodec_find_decoder_by_name(name);
2727
    if(!codec) {
2728
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2729
        av_exit(1);
2730
    }
2731
    if(codec->type != type) {
2732
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2733
        av_exit(1);
2734
    }
2735
    return codec->id;
2736
}
2737

    
2738
static void opt_input_file(const char *filename)
2739
{
2740
    AVFormatContext *ic;
2741
    AVFormatParameters params, *ap = &params;
2742
    int err, i, ret, rfps, rfps_base;
2743
    int64_t timestamp;
2744

    
2745
    if (!strcmp(filename, "-"))
2746
        filename = "pipe:";
2747

    
2748
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2749
                    !strcmp(filename, "/dev/stdin");
2750

    
2751
    /* get default parameters from command line */
2752
    ic = av_alloc_format_context();
2753

    
2754
    memset(ap, 0, sizeof(*ap));
2755
    ap->prealloced_context = 1;
2756
    ap->sample_rate = audio_sample_rate;
2757
    ap->channels = audio_channels;
2758
    ap->time_base.den = frame_rate.num;
2759
    ap->time_base.num = frame_rate.den;
2760
    ap->width = frame_width + frame_padleft + frame_padright;
2761
    ap->height = frame_height + frame_padtop + frame_padbottom;
2762
    ap->pix_fmt = frame_pix_fmt;
2763
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2764
    ap->channel = video_channel;
2765
    ap->standard = video_standard;
2766
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2767
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2768
    if(pgmyuv_compatibility_hack)
2769
        ap->video_codec_id= CODEC_ID_PGMYUV;
2770

    
2771
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2772

    
2773
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2774
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2775
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2776

    
2777
    /* open the input file with generic libav function */
2778
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2779
    if (err < 0) {
2780
        print_error(filename, err);
2781
        av_exit(1);
2782
    }
2783
    if(opt_programid) {
2784
        int i;
2785
        for(i=0; i<ic->nb_programs; i++)
2786
            if(ic->programs[i]->id != opt_programid)
2787
                ic->programs[i]->discard = AVDISCARD_ALL;
2788
    }
2789

    
2790
    ic->loop_input = loop_input;
2791

    
2792
    /* If not enough info to get the stream parameters, we decode the
2793
       first frames to get it. (used in mpeg case for example) */
2794
    ret = av_find_stream_info(ic);
2795
    if (ret < 0 && verbose >= 0) {
2796
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2797
        av_exit(1);
2798
    }
2799

    
2800
    timestamp = start_time;
2801
    /* add the stream start time */
2802
    if (ic->start_time != AV_NOPTS_VALUE)
2803
        timestamp += ic->start_time;
2804

    
2805
    /* if seeking requested, we execute it */
2806
    if (start_time != 0) {
2807
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2808
        if (ret < 0) {
2809
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2810
                    filename, (double)timestamp / AV_TIME_BASE);
2811
        }
2812
        /* reset seek info */
2813
        start_time = 0;
2814
    }
2815

    
2816
    /* update the current parameters so that they match the one of the input stream */
2817
    for(i=0;i<ic->nb_streams;i++) {
2818
        AVCodecContext *enc = ic->streams[i]->codec;
2819
        if(thread_count>1)
2820
            avcodec_thread_init(enc, thread_count);
2821
        enc->thread_count= thread_count;
2822
        switch(enc->codec_type) {
2823
        case CODEC_TYPE_AUDIO:
2824
            set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2825
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2826
            channel_layout = enc->channel_layout;
2827
            audio_channels = enc->channels;
2828
            audio_sample_rate = enc->sample_rate;
2829
            audio_sample_fmt = enc->sample_fmt;
2830
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2831
            if(audio_disable)
2832
                ic->streams[i]->discard= AVDISCARD_ALL;
2833
            break;
2834
        case CODEC_TYPE_VIDEO:
2835
            set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2836
            frame_height = enc->height;
2837
            frame_width = enc->width;
2838
            if(ic->streams[i]->sample_aspect_ratio.num)
2839
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2840
            else
2841
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2842
            frame_aspect_ratio *= (float) enc->width / enc->height;
2843
            frame_pix_fmt = enc->pix_fmt;
2844
            rfps      = ic->streams[i]->r_frame_rate.num;
2845
            rfps_base = ic->streams[i]->r_frame_rate.den;
2846
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2847
            if(me_threshold)
2848
                enc->debug |= FF_DEBUG_MV;
2849

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

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

    
2856
                    (float)rfps / rfps_base, rfps, rfps_base);
2857
            }
2858
            /* update the current frame rate to match the stream frame rate */
2859
            frame_rate.num = rfps;
2860
            frame_rate.den = rfps_base;
2861

    
2862
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2863
            if(video_disable)
2864
                ic->streams[i]->discard= AVDISCARD_ALL;
2865
            else if(video_discard)
2866
                ic->streams[i]->discard= video_discard;
2867
            break;
2868
        case CODEC_TYPE_DATA:
2869
            break;
2870
        case CODEC_TYPE_SUBTITLE:
2871
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2872
            if(subtitle_disable)
2873
                ic->streams[i]->discard = AVDISCARD_ALL;
2874
            break;
2875
        case CODEC_TYPE_ATTACHMENT:
2876
        case CODEC_TYPE_UNKNOWN:
2877
            nb_icodecs++;
2878
            break;
2879
        default:
2880
            abort();
2881
        }
2882
    }
2883

    
2884
    input_files[nb_input_files] = ic;
2885
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2886
    /* dump the file content */
2887
    if (verbose >= 0)
2888
        dump_format(ic, nb_input_files, filename, 0);
2889

    
2890
    nb_input_files++;
2891
    file_iformat = NULL;
2892
    file_oformat = NULL;
2893

    
2894
    video_channel = 0;
2895

    
2896
    av_freep(&video_codec_name);
2897
    av_freep(&audio_codec_name);
2898
    av_freep(&subtitle_codec_name);
2899
}
2900

    
2901
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2902
                                         int *has_subtitle_ptr)
2903
{
2904
    int has_video, has_audio, has_subtitle, i, j;
2905
    AVFormatContext *ic;
2906

    
2907
    has_video = 0;
2908
    has_audio = 0;
2909
    has_subtitle = 0;
2910
    for(j=0;j<nb_input_files;j++) {
2911
        ic = input_files[j];
2912
        for(i=0;i<ic->nb_streams;i++) {
2913
            AVCodecContext *enc = ic->streams[i]->codec;
2914
            switch(enc->codec_type) {
2915
            case CODEC_TYPE_AUDIO:
2916
                has_audio = 1;
2917
                break;
2918
            case CODEC_TYPE_VIDEO:
2919
                has_video = 1;
2920
                break;
2921
            case CODEC_TYPE_SUBTITLE:
2922
                has_subtitle = 1;
2923
                break;
2924
            case CODEC_TYPE_DATA:
2925
            case CODEC_TYPE_ATTACHMENT:
2926
            case CODEC_TYPE_UNKNOWN:
2927
                break;
2928
            default:
2929
                abort();
2930
            }
2931
        }
2932
    }
2933
    *has_video_ptr = has_video;
2934
    *has_audio_ptr = has_audio;
2935
    *has_subtitle_ptr = has_subtitle;
2936
}
2937

    
2938
static void new_video_stream(AVFormatContext *oc)
2939
{
2940
    AVStream *st;
2941
    AVCodecContext *video_enc;
2942
    int codec_id;
2943

    
2944
    st = av_new_stream(oc, oc->nb_streams);
2945
    if (!st) {
2946
        fprintf(stderr, "Could not alloc stream\n");
2947
        av_exit(1);
2948
    }
2949
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2950
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2951
    video_bitstream_filters= NULL;
2952

    
2953
    if(thread_count>1)
2954
        avcodec_thread_init(st->codec, thread_count);
2955

    
2956
    video_enc = st->codec;
2957

    
2958
    if(video_codec_tag)
2959
        video_enc->codec_tag= video_codec_tag;
2960

    
2961
    if(   (video_global_header&1)
2962
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2963
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2964
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2965
    }
2966
    if(video_global_header&2){
2967
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2968
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2969
    }
2970

    
2971
    if (video_stream_copy) {
2972
        st->stream_copy = 1;
2973
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2974
        video_enc->sample_aspect_ratio =
2975
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2976
    } else {
2977
        const char *p;
2978
        int i;
2979
        AVCodec *codec;
2980
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2981

    
2982
        if (video_codec_name) {
2983
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2984
            codec = avcodec_find_encoder_by_name(video_codec_name);
2985
            output_codecs[nb_ocodecs] = codec;
2986
        } else {
2987
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2988
            codec = avcodec_find_encoder(codec_id);
2989
        }
2990

    
2991
        video_enc->codec_id = codec_id;
2992

    
2993
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2994

    
2995
        if (codec && codec->supported_framerates && !force_fps)
2996
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
2997
        video_enc->time_base.den = fps.num;
2998
        video_enc->time_base.num = fps.den;
2999

    
3000
        video_enc->width = frame_width + frame_padright + frame_padleft;
3001
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3002
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3003
        video_enc->pix_fmt = frame_pix_fmt;
3004
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3005

    
3006
        if(codec && codec->pix_fmts){
3007
            const enum PixelFormat *p= codec->pix_fmts;
3008
            for(; *p!=-1; p++){
3009
                if(*p == video_enc->pix_fmt)
3010
                    break;
3011
            }
3012
            if(*p == -1)
3013
                video_enc->pix_fmt = codec->pix_fmts[0];
3014
        }
3015

    
3016
        if (intra_only)
3017
            video_enc->gop_size = 0;
3018
        if (video_qscale || same_quality) {
3019
            video_enc->flags |= CODEC_FLAG_QSCALE;
3020
            video_enc->global_quality=
3021
                st->quality = FF_QP2LAMBDA * video_qscale;
3022
        }
3023

    
3024
        if(intra_matrix)
3025
            video_enc->intra_matrix = intra_matrix;
3026
        if(inter_matrix)
3027
            video_enc->inter_matrix = inter_matrix;
3028

    
3029
        video_enc->thread_count = thread_count;
3030
        p= video_rc_override_string;
3031
        for(i=0; p; i++){
3032
            int start, end, q;
3033
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3034
            if(e!=3){
3035
                fprintf(stderr, "error parsing rc_override\n");
3036
                av_exit(1);
3037
            }
3038
            video_enc->rc_override=
3039
                av_realloc(video_enc->rc_override,
3040
                           sizeof(RcOverride)*(i+1));
3041
            video_enc->rc_override[i].start_frame= start;
3042
            video_enc->rc_override[i].end_frame  = end;
3043
            if(q>0){
3044
                video_enc->rc_override[i].qscale= q;
3045
                video_enc->rc_override[i].quality_factor= 1.0;
3046
            }
3047
            else{
3048
                video_enc->rc_override[i].qscale= 0;
3049
                video_enc->rc_override[i].quality_factor= -q/100.0;
3050
            }
3051
            p= strchr(p, '/');
3052
            if(p) p++;
3053
        }
3054
        video_enc->rc_override_count=i;
3055
        if (!video_enc->rc_initial_buffer_occupancy)
3056
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3057
        video_enc->me_threshold= me_threshold;
3058
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3059

    
3060
        if (do_psnr)
3061
            video_enc->flags|= CODEC_FLAG_PSNR;
3062

    
3063
        /* two pass mode */
3064
        if (do_pass) {
3065
            if (do_pass == 1) {
3066
                video_enc->flags |= CODEC_FLAG_PASS1;
3067
            } else {
3068
                video_enc->flags |= CODEC_FLAG_PASS2;
3069
            }
3070
        }
3071
    }
3072
    nb_ocodecs++;
3073

    
3074
    /* reset some key parameters */
3075
    video_disable = 0;
3076
    av_freep(&video_codec_name);
3077
    video_stream_copy = 0;
3078
}
3079

    
3080
static void new_audio_stream(AVFormatContext *oc)
3081
{
3082
    AVStream *st;
3083
    AVCodecContext *audio_enc;
3084
    int codec_id;
3085

    
3086
    st = av_new_stream(oc, oc->nb_streams);
3087
    if (!st) {
3088
        fprintf(stderr, "Could not alloc stream\n");
3089
        av_exit(1);
3090
    }
3091
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3092

    
3093
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3094
    audio_bitstream_filters= NULL;
3095

    
3096
    if(thread_count>1)
3097
        avcodec_thread_init(st->codec, thread_count);
3098

    
3099
    audio_enc = st->codec;
3100
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3101

    
3102
    if(audio_codec_tag)
3103
        audio_enc->codec_tag= audio_codec_tag;
3104

    
3105
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3106
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3107
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3108
    }
3109
    if (audio_stream_copy) {
3110
        st->stream_copy = 1;
3111
        audio_enc->channels = audio_channels;
3112
    } else {
3113
        AVCodec *codec;
3114

    
3115
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3116

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

    
3127
        if (audio_qscale > QSCALE_NONE) {
3128
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3129
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3130
        }
3131
        audio_enc->thread_count = thread_count;
3132
        audio_enc->channels = audio_channels;
3133
        audio_enc->sample_fmt = audio_sample_fmt;
3134
        audio_enc->channel_layout = channel_layout;
3135

    
3136
        if(codec && codec->sample_fmts){
3137
            const enum SampleFormat *p= codec->sample_fmts;
3138
            for(; *p!=-1; p++){
3139
                if(*p == audio_enc->sample_fmt)
3140
                    break;
3141
            }
3142
            if(*p == -1)
3143
                audio_enc->sample_fmt = codec->sample_fmts[0];
3144
        }
3145
    }
3146
    nb_ocodecs++;
3147
    audio_enc->sample_rate = audio_sample_rate;
3148
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3149
    if (audio_language) {
3150
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3151
        av_free(audio_language);
3152
        audio_language = NULL;
3153
    }
3154

    
3155
    /* reset some key parameters */
3156
    audio_disable = 0;
3157
    av_freep(&audio_codec_name);
3158
    audio_stream_copy = 0;
3159
}
3160

    
3161
static void new_subtitle_stream(AVFormatContext *oc)
3162
{
3163
    AVStream *st;
3164
    AVCodecContext *subtitle_enc;
3165

    
3166
    st = av_new_stream(oc, oc->nb_streams);
3167
    if (!st) {
3168
        fprintf(stderr, "Could not alloc stream\n");
3169
        av_exit(1);
3170
    }
3171
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3172

    
3173
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3174
    subtitle_bitstream_filters= NULL;
3175

    
3176
    subtitle_enc = st->codec;
3177
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3178
    if (subtitle_stream_copy) {
3179
        st->stream_copy = 1;
3180
    } else {
3181
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3182
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3183
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3184
    }
3185
    nb_ocodecs++;
3186

    
3187
    if (subtitle_language) {
3188
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3189
        av_free(subtitle_language);
3190
        subtitle_language = NULL;
3191
    }
3192

    
3193
    subtitle_disable = 0;
3194
    av_freep(&subtitle_codec_name);
3195
    subtitle_stream_copy = 0;
3196
}
3197

    
3198
static void opt_new_audio_stream(void)
3199
{
3200
    AVFormatContext *oc;
3201
    if (nb_output_files <= 0) {
3202
        fprintf(stderr, "At least one output file must be specified\n");
3203
        av_exit(1);
3204
    }
3205
    oc = output_files[nb_output_files - 1];
3206
    new_audio_stream(oc);
3207
}
3208

    
3209
static void opt_new_video_stream(void)
3210
{
3211
    AVFormatContext *oc;
3212
    if (nb_output_files <= 0) {
3213
        fprintf(stderr, "At least one output file must be specified\n");
3214
        av_exit(1);
3215
    }
3216
    oc = output_files[nb_output_files - 1];
3217
    new_video_stream(oc);
3218
}
3219

    
3220
static void opt_new_subtitle_stream(void)
3221
{
3222
    AVFormatContext *oc;
3223
    if (nb_output_files <= 0) {
3224
        fprintf(stderr, "At least one output file must be specified\n");
3225
        av_exit(1);
3226
    }
3227
    oc = output_files[nb_output_files - 1];
3228
    new_subtitle_stream(oc);
3229
}
3230

    
3231
static void opt_output_file(const char *filename)
3232
{
3233
    AVFormatContext *oc;
3234
    int use_video, use_audio, use_subtitle;
3235
    int input_has_video, input_has_audio, input_has_subtitle;
3236
    AVFormatParameters params, *ap = &params;
3237

    
3238
    if (!strcmp(filename, "-"))
3239
        filename = "pipe:";
3240

    
3241
    oc = av_alloc_format_context();
3242

    
3243
    if (!file_oformat) {
3244
        file_oformat = guess_format(NULL, filename, NULL);
3245
        if (!file_oformat) {
3246
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3247
                    filename);
3248
            av_exit(1);
3249
        }
3250
    }
3251

    
3252
    oc->oformat = file_oformat;
3253
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3254

    
3255
    if (!strcmp(file_oformat->name, "ffm") &&
3256
        av_strstart(filename, "http:", NULL)) {
3257
        /* special case for files sent to ffserver: we get the stream
3258
           parameters from ffserver */
3259
        int err = read_ffserver_streams(oc, filename);
3260
        if (err < 0) {
3261
            print_error(filename, err);
3262
            av_exit(1);
3263
        }
3264
    } else {
3265
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3266
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3267
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3268

    
3269
        /* disable if no corresponding type found and at least one
3270
           input file */
3271
        if (nb_input_files > 0) {
3272
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3273
                                         &input_has_subtitle);
3274
            if (!input_has_video)
3275
                use_video = 0;
3276
            if (!input_has_audio)
3277
                use_audio = 0;
3278
            if (!input_has_subtitle)
3279
                use_subtitle = 0;
3280
        }
3281

    
3282
        /* manual disable */
3283
        if (audio_disable) {
3284
            use_audio = 0;
3285
        }
3286
        if (video_disable) {
3287
            use_video = 0;
3288
        }
3289
        if (subtitle_disable) {
3290
            use_subtitle = 0;
3291
        }
3292

    
3293
        if (use_video) {
3294
            new_video_stream(oc);
3295
        }
3296

    
3297
        if (use_audio) {
3298
            new_audio_stream(oc);
3299
        }
3300

    
3301
        if (use_subtitle) {
3302
            new_subtitle_stream(oc);
3303
        }
3304

    
3305
        oc->timestamp = rec_timestamp;
3306

    
3307
        if (str_title)
3308
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3309
        if (str_author)
3310
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3311
        if (str_copyright)
3312
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3313
        if (str_comment)
3314
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3315
        if (str_album)
3316
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3317
        if (str_genre)
3318
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3319
    }
3320

    
3321
    output_files[nb_output_files++] = oc;
3322

    
3323
    /* check filename in case of an image number is expected */
3324
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3325
        if (!av_filename_number_test(oc->filename)) {
3326
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3327
            av_exit(1);
3328
        }
3329
    }
3330

    
3331
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3332
        /* test if it already exists to avoid loosing precious files */
3333
        if (!file_overwrite &&
3334
            (strchr(filename, ':') == NULL ||
3335
             filename[1] == ':' ||
3336
             av_strstart(filename, "file:", NULL))) {
3337
            if (url_exist(filename)) {
3338
                int c;
3339

    
3340
                if (!using_stdin) {
3341
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3342
                    fflush(stderr);
3343
                    c = getchar();
3344
                    if (toupper(c) != 'Y') {
3345
                        fprintf(stderr, "Not overwriting - exiting\n");
3346
                        av_exit(1);
3347
                    }
3348
                }
3349
                else {
3350
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3351
                    av_exit(1);
3352
                }
3353
            }
3354
        }
3355

    
3356
        /* open the file */
3357
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3358
            fprintf(stderr, "Could not open '%s'\n", filename);
3359
            av_exit(1);
3360
        }
3361
    }
3362

    
3363
    memset(ap, 0, sizeof(*ap));
3364
    if (av_set_parameters(oc, ap) < 0) {
3365
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3366
                oc->filename);
3367
        av_exit(1);
3368
    }
3369

    
3370
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3371
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3372
    oc->loop_output = loop_output;
3373

    
3374
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3375

    
3376
    /* reset some options */
3377
    file_oformat = NULL;
3378
    file_iformat = NULL;
3379
}
3380

    
3381
/* same option as mencoder */
3382
static void opt_pass(const char *pass_str)
3383
{
3384
    int pass;
3385
    pass = atoi(pass_str);
3386
    if (pass != 1 && pass != 2) {
3387
        fprintf(stderr, "pass number can be only 1 or 2\n");
3388
        av_exit(1);
3389
    }
3390
    do_pass = pass;
3391
}
3392

    
3393
static int64_t getutime(void)
3394
{
3395
#ifdef HAVE_GETRUSAGE
3396
    struct rusage rusage;
3397

    
3398
    getrusage(RUSAGE_SELF, &rusage);
3399
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3400
#elif defined(HAVE_GETPROCESSTIMES)
3401
    HANDLE proc;
3402
    FILETIME c, e, k, u;
3403
    proc = GetCurrentProcess();
3404
    GetProcessTimes(proc, &c, &e, &k, &u);
3405
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3406
#else
3407
    return av_gettime();
3408
#endif
3409
}
3410

    
3411
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3412
{
3413
    int i;
3414
    const char *p = str;
3415
    for(i = 0;; i++) {
3416
        dest[i] = atoi(p);
3417
        if(i == 63)
3418
            break;
3419
        p = strchr(p, ',');
3420
        if(!p) {
3421
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3422
            av_exit(1);
3423
        }
3424
        p++;
3425
    }
3426
}
3427

    
3428
static void opt_inter_matrix(const char *arg)
3429
{
3430
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3431
    parse_matrix_coeffs(inter_matrix, arg);
3432
}
3433

    
3434
static void opt_intra_matrix(const char *arg)
3435
{
3436
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3437
    parse_matrix_coeffs(intra_matrix, arg);
3438
}
3439

    
3440
/**
3441
 * Trivial log callback.
3442
 * Only suitable for show_help and similar since it lacks prefix handling.
3443
 */
3444
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3445
{
3446
    vfprintf(stdout, fmt, vl);
3447
}
3448

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

    
3486
static void opt_target(const char *arg)
3487
{
3488
    int norm = -1;
3489
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3490

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

    
3535
    if(norm < 0) {
3536
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3537
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3538
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3539
        av_exit(1);
3540
    }
3541

    
3542
    if(!strcmp(arg, "vcd")) {
3543

    
3544
        opt_video_codec("mpeg1video");
3545
        opt_audio_codec("mp2");
3546
        opt_format("vcd");
3547

    
3548
        opt_frame_size(norm ? "352x240" : "352x288");
3549
        opt_frame_rate(NULL, frame_rates[norm]);
3550
        opt_default("gop", norm ? "18" : "15");
3551

    
3552
        opt_default("b", "1150000");
3553
        opt_default("maxrate", "1150000");
3554
        opt_default("minrate", "1150000");
3555
        opt_default("bufsize", "327680"); // 40*1024*8;
3556

    
3557
        opt_default("ab", "224000");
3558
        audio_sample_rate = 44100;
3559
        audio_channels = 2;
3560

    
3561
        opt_default("packetsize", "2324");
3562
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3563

    
3564
        /* We have to offset the PTS, so that it is consistent with the SCR.
3565
           SCR starts at 36000, but the first two packs contain only padding
3566
           and the first pack from the other stream, respectively, may also have
3567
           been written before.
3568
           So the real data starts at SCR 36000+3*1200. */
3569
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3570
    } else if(!strcmp(arg, "svcd")) {
3571

    
3572
        opt_video_codec("mpeg2video");
3573
        opt_audio_codec("mp2");
3574
        opt_format("svcd");
3575

    
3576
        opt_frame_size(norm ? "480x480" : "480x576");
3577
        opt_frame_rate(NULL, frame_rates[norm]);
3578
        opt_default("gop", norm ? "18" : "15");
3579

    
3580
        opt_default("b", "2040000");
3581
        opt_default("maxrate", "2516000");
3582
        opt_default("minrate", "0"); //1145000;
3583
        opt_default("bufsize", "1835008"); //224*1024*8;
3584
        opt_default("flags", "+scan_offset");
3585

    
3586

    
3587
        opt_default("ab", "224000");
3588
        audio_sample_rate = 44100;
3589

    
3590
        opt_default("packetsize", "2324");
3591

    
3592
    } else if(!strcmp(arg, "dvd")) {
3593

    
3594
        opt_video_codec("mpeg2video");
3595
        opt_audio_codec("ac3");
3596
        opt_format("dvd");
3597

    
3598
        opt_frame_size(norm ? "720x480" : "720x576");
3599
        opt_frame_rate(NULL, frame_rates[norm]);
3600
        opt_default("gop", norm ? "18" : "15");
3601

    
3602
        opt_default("b", "6000000");
3603
        opt_default("maxrate", "9000000");
3604
        opt_default("minrate", "0"); //1500000;
3605
        opt_default("bufsize", "1835008"); //224*1024*8;
3606

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

    
3610
        opt_default("ab", "448000");
3611
        audio_sample_rate = 48000;
3612

    
3613
    } else if(!strncmp(arg, "dv", 2)) {
3614

    
3615
        opt_format("dv");
3616

    
3617
        opt_frame_size(norm ? "720x480" : "720x576");
3618
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3619
                                             (norm ? "yuv411p" : "yuv420p"));
3620
        opt_frame_rate(NULL, frame_rates[norm]);
3621

    
3622
        audio_sample_rate = 48000;
3623
        audio_channels = 2;
3624

    
3625
    } else {
3626
        fprintf(stderr, "Unknown target: %s\n", arg);
3627
        av_exit(1);
3628
    }
3629
}
3630

    
3631
static void opt_vstats_file (const char *arg)
3632
{
3633
    av_free (vstats_filename);
3634
    vstats_filename=av_strdup (arg);
3635
}
3636

    
3637
static void opt_vstats (void)
3638
{
3639
    char filename[40];
3640
    time_t today2 = time(NULL);
3641
    struct tm *today = localtime(&today2);
3642

    
3643
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3644
             today->tm_sec);
3645
    opt_vstats_file(filename);
3646
}
3647

    
3648
static int opt_bsf(const char *opt, const char *arg)
3649
{
3650
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3651
    AVBitStreamFilterContext **bsfp;
3652

    
3653
    if(!bsfc){
3654
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3655
        av_exit(1);
3656
    }
3657

    
3658
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3659
          *opt == 'a' ? &audio_bitstream_filters :
3660
                        &subtitle_bitstream_filters;
3661
    while(*bsfp)
3662
        bsfp= &(*bsfp)->next;
3663

    
3664
    *bsfp= bsfc;
3665

    
3666
    return 0;
3667
}
3668

    
3669
static int opt_preset(const char *opt, const char *arg)
3670
{
3671
    FILE *f=NULL;
3672
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3673
    int i;
3674
    const char *base[3]= { getenv("HOME"),
3675
                           "/usr/local/share",
3676
                           "/usr/share",
3677
                         };
3678

    
3679
    for(i=!base[0]; i<3 && !f; i++){
3680
        snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3681
        f= fopen(filename, "r");
3682
        if(!f){
3683
            char *codec_name= *opt == 'v' ? video_codec_name :
3684
                              *opt == 'a' ? audio_codec_name :
3685
                                            subtitle_codec_name;
3686
            snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3687
            f= fopen(filename, "r");
3688
        }
3689
    }
3690
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3691
              is_dos_path(arg))){
3692
        snprintf(filename, sizeof(filename), arg);
3693
        f= fopen(filename, "r");
3694
    }
3695

    
3696
    if(!f){
3697
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3698
        av_exit(1);
3699
    }
3700

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

    
3722
    fclose(f);
3723

    
3724
    return 0;
3725
}
3726

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

    
3774
    /* video options */
3775
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3776
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3777
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3778
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3779
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3780
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3781
    { "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" },
3782
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3783
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3784
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3785
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3786
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3787
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3788
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3789
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3790
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3791
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3792
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3793
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3794
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3795
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3796
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3797
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3798
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3799
      "use same video quality as source (implies VBR)" },
3800
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3801
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3802
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3803
      "deinterlace pictures" },
3804
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3805
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3806
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3807
#ifdef CONFIG_VHOOK
3808
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3809
#endif
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 = av_alloc_format_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
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3896
              stream_maps, nb_stream_maps);
3897
    ti = getutime() - ti;
3898
    if (do_benchmark) {
3899
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3900
    }
3901

    
3902
    return av_exit(0);
3903
}