Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ c44c4e18

History | View | Annotate | Download (137 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 500
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 int nb_input_files = 0;
98

    
99
static AVFormatContext *output_files[MAX_FILES];
100
static int nb_output_files = 0;
101

    
102
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
103
static int nb_stream_maps;
104

    
105
static AVMetaDataMap meta_data_maps[MAX_FILES];
106
static int nb_meta_data_maps;
107

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

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

    
158
static int subtitle_disable = 0;
159
static char *subtitle_codec_name = NULL;
160
static char *subtitle_language = NULL;
161

    
162
static float mux_preload= 0.5;
163
static float mux_max_delay= 0.7;
164

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

    
195
static int rate_emu = 0;
196

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

    
200
static int audio_volume = 256;
201

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

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

    
220
static unsigned int sws_flags = SWS_BICUBIC;
221

    
222
static int64_t timer_start;
223

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

    
229
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
230

    
231
struct AVInputStream;
232

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

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

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

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

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

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

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

    
293
#ifdef HAVE_TERMIOS_H
294

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

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

    
306
static volatile sig_atomic_t received_sigterm = 0;
307

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

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

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

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

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

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

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

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

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

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

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

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

    
402
    av_free(intra_matrix);
403
    av_free(inter_matrix);
404

    
405
    if (vstats_file)
406
        fclose(vstats_file);
407
    av_free(vstats_filename);
408

    
409
    av_free(opt_names);
410

    
411
    av_free(video_codec_name);
412
    av_free(audio_codec_name);
413
    av_free(subtitle_codec_name);
414

    
415
    av_free(video_standard);
416

    
417
#ifdef CONFIG_POWERPC_PERF
418
    extern void powerpc_display_perf_report(void);
419
    powerpc_display_perf_report();
420
#endif /* CONFIG_POWERPC_PERF */
421

    
422
    if (received_sigterm) {
423
        fprintf(stderr,
424
            "Received signal %d: terminating.\n",
425
            (int) received_sigterm);
426
        exit (255);
427
    }
428

    
429
    exit(ret); /* not all OS-es handle main() return value */
430
    return ret;
431
}
432

    
433
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
434
{
435
    int i, err;
436
    AVFormatContext *ic;
437
    int nopts = 0;
438

    
439
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
440
    if (err < 0)
441
        return err;
442
    /* copy stream format */
443
    s->nb_streams = ic->nb_streams;
444
    for(i=0;i<ic->nb_streams;i++) {
445
        AVStream *st;
446

    
447
        // FIXME: a more elegant solution is needed
448
        st = av_mallocz(sizeof(AVStream));
449
        memcpy(st, ic->streams[i], sizeof(AVStream));
450
        st->codec = avcodec_alloc_context();
451
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
452
        s->streams[i] = st;
453

    
454
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
455
            st->stream_copy = 1;
456
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
457
            st->stream_copy = 1;
458

    
459
        if(!st->codec->thread_count)
460
            st->codec->thread_count = 1;
461
        if(st->codec->thread_count>1)
462
            avcodec_thread_init(st->codec, st->codec->thread_count);
463

    
464
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
465
            nopts = 1;
466
    }
467

    
468
    if (!nopts)
469
        s->timestamp = av_gettime();
470

    
471
    av_close_input_file(ic);
472
    return 0;
473
}
474

    
475
static double
476
get_sync_ipts(const AVOutputStream *ost)
477
{
478
    const AVInputStream *ist = ost->sync_ist;
479
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
480
}
481

    
482
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
483
    int ret;
484

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

    
504
        bsfc= bsfc->next;
505
    }
506

    
507
    ret= av_interleaved_write_frame(s, pkt);
508
    if(ret < 0){
509
        print_error("av_interleaved_write_frame()", ret);
510
        av_exit(1);
511
    }
512
}
513

    
514
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
515

    
516
static void do_audio_out(AVFormatContext *s,
517
                         AVOutputStream *ost,
518
                         AVInputStream *ist,
519
                         unsigned char *buf, int size)
520
{
521
    uint8_t *buftmp;
522
    static uint8_t *audio_buf = NULL;
523
    static uint8_t *audio_out = NULL;
524
    static uint8_t *audio_out2 = NULL;
525
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
526

    
527
    int size_out, frame_bytes, ret;
528
    AVCodecContext *enc= ost->st->codec;
529
    AVCodecContext *dec= ist->st->codec;
530
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
531
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
532

    
533
    /* SC: dynamic allocation of buffers */
534
    if (!audio_buf)
535
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
536
    if (!audio_out)
537
        audio_out = av_malloc(audio_out_size);
538
    if (!audio_buf || !audio_out)
539
        return;               /* Should signal an error ! */
540

    
541
    if (enc->channels != dec->channels)
542
        ost->audio_resample = 1;
543

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

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

    
579
    if(audio_sync_method){
580
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
581
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
582
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
583
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
584

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

    
601
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
602
                        ist->is_start=0;
603
                    else
604
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
605

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

    
626
    if (ost->audio_resample) {
627
        buftmp = audio_buf;
628
        size_out = audio_resample(ost->resample,
629
                                  (short *)buftmp, (short *)buf,
630
                                  size / (ist->st->codec->channels * isize));
631
        size_out = size_out * enc->channels * osize;
632
    } else {
633
        buftmp = buf;
634
        size_out = size;
635
    }
636

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

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

    
662
        frame_bytes = enc->frame_size * osize * enc->channels;
663

    
664
        while (av_fifo_size(&ost->fifo) >= frame_bytes) {
665
            AVPacket pkt;
666
            av_init_packet(&pkt);
667

    
668
            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
669

    
670
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
671

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

    
683
            ost->sync_opts += enc->frame_size;
684
        }
685
    } else {
686
        AVPacket pkt;
687
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
688
        av_init_packet(&pkt);
689

    
690
        ost->sync_opts += size_out / (osize * enc->channels);
691

    
692
        /* output a pcm frame */
693
        /* determine the size of the coded buffer */
694
        size_out /= osize;
695
        if (coded_bps)
696
            size_out *= coded_bps;
697

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

    
712
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
713
{
714
    AVCodecContext *dec;
715
    AVPicture *picture2;
716
    AVPicture picture_tmp;
717
    uint8_t *buf = 0;
718

    
719
    dec = ist->st->codec;
720

    
721
    /* deinterlace : must be done before any resize */
722
    if (do_deinterlace || using_vhook) {
723
        int size;
724

    
725
        /* create temporary picture */
726
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
727
        buf = av_malloc(size);
728
        if (!buf)
729
            return;
730

    
731
        picture2 = &picture_tmp;
732
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
733

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

    
750
    if (ENABLE_VHOOK)
751
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
752
                           1000000 * ist->pts / AV_TIME_BASE);
753

    
754
    if (picture != picture2)
755
        *picture = *picture2;
756
    *bufp = buf;
757
}
758

    
759
/* we begin to correct av delay at this threshold */
760
#define AV_DELAY_MAX 0.100
761

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

    
774
    if (pts == AV_NOPTS_VALUE) {
775
        fprintf(stderr, "Subtitle packets must have a pts\n");
776
        if (exit_on_error)
777
            av_exit(1);
778
        return;
779
    }
780

    
781
    enc = ost->st->codec;
782

    
783
    if (!subtitle_out) {
784
        subtitle_out = av_malloc(subtitle_out_max_size);
785
    }
786

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

    
795
    for(i = 0; i < nb; i++) {
796
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
797
                                                    subtitle_out_max_size, sub);
798

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

    
816
static int bit_buffer_size= 1024*256;
817
static uint8_t *bit_buffer= NULL;
818

    
819
static void do_video_out(AVFormatContext *s,
820
                         AVOutputStream *ost,
821
                         AVInputStream *ist,
822
                         AVFrame *in_picture,
823
                         int *frame_size)
824
{
825
    int nb_frames, i, ret;
826
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
827
    AVFrame picture_crop_temp, picture_pad_temp;
828
    AVCodecContext *enc, *dec;
829

    
830
    avcodec_get_frame_defaults(&picture_crop_temp);
831
    avcodec_get_frame_defaults(&picture_pad_temp);
832

    
833
    enc = ost->st->codec;
834
    dec = ist->st->codec;
835

    
836
    /* by default, we output a single frame */
837
    nb_frames = 1;
838

    
839
    *frame_size = 0;
840

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

    
864
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
865
    if (nb_frames <= 0)
866
        return;
867

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

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

    
896
    if (ost->video_resample) {
897
        padding_src = NULL;
898
        final_picture = &ost->pict_tmp;
899
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
900
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
901
    }
902

    
903
    if (ost->video_pad) {
904
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
905
                enc->height, enc->width, enc->pix_fmt,
906
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
907
    }
908

    
909
    /* duplicates frame if needed */
910
    for(i=0;i<nb_frames;i++) {
911
        AVPacket pkt;
912
        av_init_packet(&pkt);
913
        pkt.stream_index= ost->index;
914

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

    
926
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
927
            enc->coded_frame = old_frame;
928
        } else {
929
            AVFrame big_picture;
930

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

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

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

    
990
static double psnr(double d){
991
    return -10.0*log(d)/log(10.0);
992
}
993

    
994
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
995
                           int frame_size)
996
{
997
    AVCodecContext *enc;
998
    int frame_number;
999
    double ti1, bitrate, avg_bitrate;
1000

    
1001
    /* this is executed just the first time do_video_stats is called */
1002
    if (!vstats_file) {
1003
        vstats_file = fopen(vstats_filename, "w");
1004
        if (!vstats_file) {
1005
            perror("fopen");
1006
            av_exit(1);
1007
        }
1008
    }
1009

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

    
1017
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1018
        /* compute pts value */
1019
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1020
        if (ti1 < 0.01)
1021
            ti1 = 0.01;
1022

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

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

    
1045
    if (!is_last_report) {
1046
        int64_t cur_time;
1047
        /* display the report every 0.5 seconds */
1048
        cur_time = av_gettime();
1049
        if (last_time == -1) {
1050
            last_time = cur_time;
1051
            return;
1052
        }
1053
        if ((cur_time - last_time) < 500000)
1054
            return;
1055
        last_time = cur_time;
1056
    }
1057

    
1058

    
1059
    oc = output_files[0];
1060

    
1061
    total_size = url_fsize(oc->pb);
1062
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1063
        total_size= url_ftell(oc->pb);
1064

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

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

    
1126
    if (verbose || is_last_report) {
1127
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1128

    
1129
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1130
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1131
            (double)total_size / 1024, ti1, bitrate);
1132

    
1133
        if (verbose > 1)
1134
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1135
                  nb_frames_dup, nb_frames_drop);
1136

    
1137
        if (verbose >= 0)
1138
            fprintf(stderr, "%s    \r", buf);
1139

    
1140
        fflush(stderr);
1141
    }
1142

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

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

    
1173
    if(ist->next_pts == AV_NOPTS_VALUE)
1174
        ist->next_pts= ist->pts;
1175

    
1176
    if (pkt == NULL) {
1177
        /* EOF handling */
1178
        ptr = NULL;
1179
        len = 0;
1180
        goto handle_eof;
1181
    }
1182

    
1183
    if(pkt->dts != AV_NOPTS_VALUE)
1184
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1185

    
1186
    len = pkt->size;
1187
    ptr = pkt->data;
1188

    
1189
    //while we have more to decode or while the decoder did output something on EOF
1190
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1191
    handle_eof:
1192
        ist->pts= ist->next_pts;
1193

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

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

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

    
1283
        buffer_to_free = NULL;
1284
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1285
            pre_process_video_frame(ist, (AVPicture *)&picture,
1286
                                    &buffer_to_free);
1287
        }
1288

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

    
1303
        /* frame rate emulation */
1304
        if (ist->st->codec->rate_emu) {
1305
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1306
            int64_t now = av_gettime() - ist->start;
1307
            if (pts > now)
1308
                usleep(pts - now);
1309

    
1310
            ist->frame++;
1311
        }
1312

    
1313
#if 0
1314
        /* mpeg PTS deordering : if it is a P or I frame, the PTS
1315
           is the one of the next displayed one */
1316
        /* XXX: add mpeg4 too ? */
1317
        if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1318
            if (ist->st->codec->pict_type != B_TYPE) {
1319
                int64_t tmp;
1320
                tmp = ist->last_ip_pts;
1321
                ist->last_ip_pts  = ist->frac_pts.val;
1322
                ist->frac_pts.val = tmp;
1323
            }
1324
        }
1325
#endif
1326
        /* if output time reached then transcode raw format,
1327
           encode packets and output them */
1328
        if (start_time == 0 || ist->pts >= start_time)
1329
            for(i=0;i<nb_ostreams;i++) {
1330
                int frame_size;
1331

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1476
                        if(ret<=0)
1477
                            break;
1478
                        pkt.data= bit_buffer;
1479
                        pkt.size= ret;
1480
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1481
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1482
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1483
                    }
1484
                }
1485
            }
1486
        }
1487
    }
1488

    
1489
    return 0;
1490
 fail_decode:
1491
    return -1;
1492
}
1493

    
1494
static void print_sdp(AVFormatContext **avc, int n)
1495
{
1496
    char sdp[2048];
1497

    
1498
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1499
    printf("SDP:\n%s\n", sdp);
1500
}
1501

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

    
1525
    return -1;
1526
}
1527

    
1528
/*
1529
 * The following code is the main loop of the file converter
1530
 */
1531
static int av_encode(AVFormatContext **output_files,
1532
                     int nb_output_files,
1533
                     AVFormatContext **input_files,
1534
                     int nb_input_files,
1535
                     AVStreamMap *stream_maps, int nb_stream_maps)
1536
{
1537
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1538
    AVFormatContext *is, *os;
1539
    AVCodecContext *codec, *icodec;
1540
    AVOutputStream *ost, **ost_table = NULL;
1541
    AVInputStream *ist, **ist_table = NULL;
1542
    AVInputFile *file_table;
1543
    int key;
1544
    int want_sdp = 1;
1545

    
1546
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1547
    if (!file_table)
1548
        goto fail;
1549

    
1550
    /* input stream init */
1551
    j = 0;
1552
    for(i=0;i<nb_input_files;i++) {
1553
        is = input_files[i];
1554
        file_table[i].ist_index = j;
1555
        file_table[i].nb_streams = is->nb_streams;
1556
        j += is->nb_streams;
1557
    }
1558
    nb_istreams = j;
1559

    
1560
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1561
    if (!ist_table)
1562
        goto fail;
1563

    
1564
    for(i=0;i<nb_istreams;i++) {
1565
        ist = av_mallocz(sizeof(AVInputStream));
1566
        if (!ist)
1567
            goto fail;
1568
        ist_table[i] = ist;
1569
    }
1570
    j = 0;
1571
    for(i=0;i<nb_input_files;i++) {
1572
        is = input_files[i];
1573
        for(k=0;k<is->nb_streams;k++) {
1574
            ist = ist_table[j++];
1575
            ist->st = is->streams[k];
1576
            ist->file_index = i;
1577
            ist->index = k;
1578
            ist->discard = 1; /* the stream is discarded by default
1579
                                 (changed later) */
1580

    
1581
            if (ist->st->codec->rate_emu) {
1582
                ist->start = av_gettime();
1583
                ist->frame = 0;
1584
            }
1585
        }
1586
    }
1587

    
1588
    /* output stream init */
1589
    nb_ostreams = 0;
1590
    for(i=0;i<nb_output_files;i++) {
1591
        os = output_files[i];
1592
        if (!os->nb_streams) {
1593
            fprintf(stderr, "Output file does not contain any stream\n");
1594
            av_exit(1);
1595
        }
1596
        nb_ostreams += os->nb_streams;
1597
    }
1598
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1599
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1600
        av_exit(1);
1601
    }
1602

    
1603
    /* Sanity check the mapping args -- do the input files & streams exist? */
1604
    for(i=0;i<nb_stream_maps;i++) {
1605
        int fi = stream_maps[i].file_index;
1606
        int si = stream_maps[i].stream_index;
1607

    
1608
        if (fi < 0 || fi > nb_input_files - 1 ||
1609
            si < 0 || si > file_table[fi].nb_streams - 1) {
1610
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1611
            av_exit(1);
1612
        }
1613
        fi = stream_maps[i].sync_file_index;
1614
        si = stream_maps[i].sync_stream_index;
1615
        if (fi < 0 || fi > nb_input_files - 1 ||
1616
            si < 0 || si > file_table[fi].nb_streams - 1) {
1617
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1618
            av_exit(1);
1619
        }
1620
    }
1621

    
1622
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1623
    if (!ost_table)
1624
        goto fail;
1625
    for(i=0;i<nb_ostreams;i++) {
1626
        ost = av_mallocz(sizeof(AVOutputStream));
1627
        if (!ost)
1628
            goto fail;
1629
        ost_table[i] = ost;
1630
    }
1631

    
1632
    n = 0;
1633
    for(k=0;k<nb_output_files;k++) {
1634
        os = output_files[k];
1635
        for(i=0;i<os->nb_streams;i++,n++) {
1636
            int found;
1637
            ost = ost_table[n];
1638
            ost->file_index = k;
1639
            ost->index = i;
1640
            ost->st = os->streams[i];
1641
            if (nb_stream_maps > 0) {
1642
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1643
                    stream_maps[n].stream_index;
1644

    
1645
                /* Sanity check that the stream types match */
1646
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1647
                    int i= ost->file_index;
1648
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1649
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1650
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1651
                        ost->file_index, ost->index);
1652
                    av_exit(1);
1653
                }
1654

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

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

    
1705
    /* for each output stream, we compute the right encoding parameters */
1706
    for(i=0;i<nb_ostreams;i++) {
1707
        ost = ost_table[i];
1708
        os = output_files[ost->file_index];
1709
        ist = ist_table[ost->source_index];
1710

    
1711
        codec = ost->st->codec;
1712
        icodec = ist->st->codec;
1713

    
1714
        if (!ost->st->language[0])
1715
            av_strlcpy(ost->st->language, ist->st->language,
1716
                       sizeof(ost->st->language));
1717

    
1718
        ost->st->disposition = ist->st->disposition;
1719

    
1720
        if (ost->st->stream_copy) {
1721
            /* if stream_copy is selected, no need to decode or encode */
1722
            codec->codec_id = icodec->codec_id;
1723
            codec->codec_type = icodec->codec_type;
1724

    
1725
            if(!codec->codec_tag){
1726
                if(   !os->oformat->codec_tag
1727
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1728
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1729
                    codec->codec_tag = icodec->codec_tag;
1730
            }
1731

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

    
1847
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1848
                         pass_logfilename ?
1849
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1850
                if (codec->flags & CODEC_FLAG_PASS1) {
1851
                    f = fopen(logfilename, "w");
1852
                    if (!f) {
1853
                        perror(logfilename);
1854
                        av_exit(1);
1855
                    }
1856
                    ost->logfile = f;
1857
                } else {
1858
                    /* read the log file */
1859
                    f = fopen(logfilename, "r");
1860
                    if (!f) {
1861
                        perror(logfilename);
1862
                        av_exit(1);
1863
                    }
1864
                    fseek(f, 0, SEEK_END);
1865
                    size = ftell(f);
1866
                    fseek(f, 0, SEEK_SET);
1867
                    logbuffer = av_malloc(size + 1);
1868
                    if (!logbuffer) {
1869
                        fprintf(stderr, "Could not allocate log buffer\n");
1870
                        av_exit(1);
1871
                    }
1872
                    size = fread(logbuffer, 1, size, f);
1873
                    fclose(f);
1874
                    logbuffer[size] = '\0';
1875
                    codec->stats_in = logbuffer;
1876
                }
1877
            }
1878
        }
1879
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1880
            int size= codec->width * codec->height;
1881
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1882
        }
1883
    }
1884

    
1885
    if (!bit_buffer)
1886
        bit_buffer = av_malloc(bit_buffer_size);
1887
    if (!bit_buffer)
1888
        goto fail;
1889

    
1890
    /* dump the file output parameters - cannot be done before in case
1891
       of stream copy */
1892
    for(i=0;i<nb_output_files;i++) {
1893
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1894
    }
1895

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

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

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

    
1955
    /* init pts */
1956
    for(i=0;i<nb_istreams;i++) {
1957
        ist = ist_table[i];
1958
        is = input_files[ist->file_index];
1959
        ist->pts = 0;
1960
        ist->next_pts = AV_NOPTS_VALUE;
1961
        ist->is_start = 1;
1962
    }
1963

    
1964
    /* set meta data information from input file if required */
1965
    for (i=0;i<nb_meta_data_maps;i++) {
1966
        AVFormatContext *out_file;
1967
        AVFormatContext *in_file;
1968

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

    
1982
        out_file = output_files[out_file_index];
1983
        in_file = input_files[in_file_index];
1984

    
1985
        strcpy(out_file->title, in_file->title);
1986
        strcpy(out_file->author, in_file->author);
1987
        strcpy(out_file->copyright, in_file->copyright);
1988
        strcpy(out_file->comment, in_file->comment);
1989
        strcpy(out_file->album, in_file->album);
1990
        out_file->year = in_file->year;
1991
        out_file->track = in_file->track;
1992
        strcpy(out_file->genre, in_file->genre);
1993
    }
1994

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

    
2011
    if (!using_stdin && verbose >= 0) {
2012
        fprintf(stderr, "Press [q] to stop encoding\n");
2013
        url_set_interrupt_cb(decode_interrupt_cb);
2014
    }
2015
    term_init();
2016

    
2017
    key = -1;
2018
    timer_start = av_gettime();
2019

    
2020
    for(; received_sigterm == 0;) {
2021
        int file_index, ist_index;
2022
        AVPacket pkt;
2023
        double ipts_min;
2024
        double opts_min;
2025

    
2026
    redo:
2027
        ipts_min= 1e100;
2028
        opts_min= 1e100;
2029
        /* if 'q' pressed, exits */
2030
        if (!using_stdin) {
2031
            if (q_pressed)
2032
                break;
2033
            /* read_key() returns 0 on EOF */
2034
            key = read_key();
2035
            if (key == 'q')
2036
                break;
2037
        }
2038

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

    
2072
        /* finish if recording time exhausted */
2073
        if (opts_min >= (recording_time / 1000000.0))
2074
            break;
2075

    
2076
        /* finish if limit size exhausted */
2077
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2078
            break;
2079

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

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

    
2102
        if (pkt.dts != AV_NOPTS_VALUE)
2103
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2104
        if (pkt.pts != AV_NOPTS_VALUE)
2105
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2106

    
2107
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2108
            if(pkt.pts != AV_NOPTS_VALUE)
2109
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2110
            if(pkt.dts != AV_NOPTS_VALUE)
2111
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2112
        }
2113

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

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

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

    
2140
    discard_packet:
2141
        av_free_packet(&pkt);
2142

    
2143
        /* dump report by using the output first video and audio streams */
2144
        print_report(output_files, ost_table, nb_ostreams, 0);
2145
    }
2146

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

    
2155
    term_exit();
2156

    
2157
    /* write the trailer if needed and close file */
2158
    for(i=0;i<nb_output_files;i++) {
2159
        os = output_files[i];
2160
        av_write_trailer(os);
2161
    }
2162

    
2163
    /* dump report by using the first video and audio streams */
2164
    print_report(output_files, ost_table, nb_ostreams, 1);
2165

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

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

    
2183
    /* finished ! */
2184

    
2185
    ret = 0;
2186
 fail1:
2187
    av_freep(&bit_buffer);
2188
    av_free(file_table);
2189

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

    
2225
#if 0
2226
int file_read(const char *filename)
2227
{
2228
    URLContext *h;
2229
    unsigned char buffer[1024];
2230
    int len, i;
2231

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

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

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

    
2265
static void opt_video_rc_override_string(const char *arg)
2266
{
2267
    video_rc_override_string = arg;
2268
}
2269

    
2270
static int opt_me_threshold(const char *opt, const char *arg)
2271
{
2272
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2273
    return 0;
2274
}
2275

    
2276
static int opt_verbose(const char *opt, const char *arg)
2277
{
2278
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2279
    av_log_set_level(verbose);
2280
    return 0;
2281
}
2282

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

    
2292
static int opt_bitrate(const char *opt, const char *arg)
2293
{
2294
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2295

    
2296
    opt_default(opt, arg);
2297

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

    
2301
    return 0;
2302
}
2303

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

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

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

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

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

    
2388

    
2389
#define SCALEBITS 10
2390
#define ONE_HALF  (1 << (SCALEBITS - 1))
2391
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2392

    
2393
#define RGB_TO_Y(r, g, b) \
2394
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2395
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2396

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

    
2401
#define RGB_TO_V(r1, g1, b1, shift)\
2402
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2403
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2404

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

    
2411
    r = (rgb >> 16);
2412
    g = ((rgb >> 8) & 255);
2413
    b = (rgb & 255);
2414

    
2415
    padcolor[0] = RGB_TO_Y(r,g,b);
2416
    padcolor[1] = RGB_TO_U(r,g,b,0);
2417
    padcolor[2] = RGB_TO_V(r,g,b,0);
2418
}
2419

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

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

    
2446

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

    
2460

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

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

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

    
2494
static void opt_frame_aspect_ratio(const char *arg)
2495
{
2496
    int x = 0, y = 0;
2497
    double ar = 0;
2498
    const char *p;
2499
    char *end;
2500

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

    
2511
    if (!ar) {
2512
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2513
        av_exit(1);
2514
    }
2515
    frame_aspect_ratio = ar;
2516
}
2517

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

    
2528
static void opt_top_field_first(const char *arg)
2529
{
2530
    top_field_first= atoi(arg);
2531
}
2532

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

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

    
2553
static int opt_audio_rate(const char *opt, const char *arg)
2554
{
2555
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2556
    return 0;
2557
}
2558

    
2559
static int opt_audio_channels(const char *opt, const char *arg)
2560
{
2561
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2562
    return 0;
2563
}
2564

    
2565
static void opt_video_channel(const char *arg)
2566
{
2567
    video_channel = strtol(arg, NULL, 0);
2568
}
2569

    
2570
static void opt_video_standard(const char *arg)
2571
{
2572
    video_standard = av_strdup(arg);
2573
}
2574

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

    
2586
static void opt_audio_codec(const char *arg)
2587
{
2588
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2589
}
2590

    
2591
static void opt_audio_tag(const char *arg)
2592
{
2593
    char *tail;
2594
    audio_codec_tag= strtol(arg, &tail, 0);
2595

    
2596
    if(!tail || *tail)
2597
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2598
}
2599

    
2600
static void opt_video_tag(const char *arg)
2601
{
2602
    char *tail;
2603
    video_codec_tag= strtol(arg, &tail, 0);
2604

    
2605
    if(!tail || *tail)
2606
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2607
}
2608

    
2609
#ifdef CONFIG_VHOOK
2610
static void add_frame_hooker(const char *arg)
2611
{
2612
    int argc = 0;
2613
    char *argv[64];
2614
    int i;
2615
    char *args = av_strdup(arg);
2616

    
2617
    using_vhook = 1;
2618

    
2619
    argv[0] = strtok(args, " ");
2620
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2621
    }
2622

    
2623
    i = frame_hook_add(argc, argv);
2624

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

    
2632
static void opt_video_codec(const char *arg)
2633
{
2634
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2635
}
2636

    
2637
static void opt_subtitle_codec(const char *arg)
2638
{
2639
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2640
}
2641

    
2642
static void opt_map(const char *arg)
2643
{
2644
    AVStreamMap *m;
2645
    char *p;
2646

    
2647
    m = &stream_maps[nb_stream_maps++];
2648

    
2649
    m->file_index = strtol(arg, &p, 0);
2650
    if (*p)
2651
        p++;
2652

    
2653
    m->stream_index = strtol(p, &p, 0);
2654
    if (*p) {
2655
        p++;
2656
        m->sync_file_index = strtol(p, &p, 0);
2657
        if (*p)
2658
            p++;
2659
        m->sync_stream_index = strtol(p, &p, 0);
2660
    } else {
2661
        m->sync_file_index = m->file_index;
2662
        m->sync_stream_index = m->stream_index;
2663
    }
2664
}
2665

    
2666
static void opt_map_meta_data(const char *arg)
2667
{
2668
    AVMetaDataMap *m;
2669
    char *p;
2670

    
2671
    m = &meta_data_maps[nb_meta_data_maps++];
2672

    
2673
    m->out_file = strtol(arg, &p, 0);
2674
    if (*p)
2675
        p++;
2676

    
2677
    m->in_file = strtol(p, &p, 0);
2678
}
2679

    
2680
static void opt_input_ts_scale(const char *arg)
2681
{
2682
    unsigned int stream;
2683
    double scale;
2684
    char *p;
2685

    
2686
    stream = strtol(arg, &p, 0);
2687
    if (*p)
2688
        p++;
2689
    scale= strtod(p, &p);
2690

    
2691
    if(stream >= MAX_STREAMS)
2692
        av_exit(1);
2693

    
2694
    input_files_ts_scale[nb_input_files][stream]= scale;
2695
}
2696

    
2697
static int opt_recording_time(const char *opt, const char *arg)
2698
{
2699
    recording_time = parse_time_or_die(opt, arg, 1);
2700
    return 0;
2701
}
2702

    
2703
static int opt_start_time(const char *opt, const char *arg)
2704
{
2705
    start_time = parse_time_or_die(opt, arg, 1);
2706
    return 0;
2707
}
2708

    
2709
static int opt_rec_timestamp(const char *opt, const char *arg)
2710
{
2711
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2712
    return 0;
2713
}
2714

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

    
2721
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2722
{
2723
    const char *codec_string = encoder ? "encoder" : "decoder";
2724
    AVCodec *codec;
2725

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

    
2742
static void opt_input_file(const char *filename)
2743
{
2744
    AVFormatContext *ic;
2745
    AVFormatParameters params, *ap = &params;
2746
    int err, i, ret, rfps, rfps_base;
2747
    int64_t timestamp;
2748

    
2749
    if (!strcmp(filename, "-"))
2750
        filename = "pipe:";
2751

    
2752
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2753
                    !strcmp(filename, "/dev/stdin");
2754

    
2755
    /* get default parameters from command line */
2756
    ic = av_alloc_format_context();
2757

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

    
2775
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2776

    
2777
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2778
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2779
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2780

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

    
2794
    ic->loop_input = loop_input;
2795

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

    
2804
    timestamp = start_time;
2805
    /* add the stream start time */
2806
    if (ic->start_time != AV_NOPTS_VALUE)
2807
        timestamp += ic->start_time;
2808

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

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

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

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

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

    
2864
            enc->rate_emu = rate_emu;
2865
            if(video_disable)
2866
                ic->streams[i]->discard= AVDISCARD_ALL;
2867
            else if(video_discard)
2868
                ic->streams[i]->discard= video_discard;
2869
            break;
2870
        case CODEC_TYPE_DATA:
2871
            break;
2872
        case CODEC_TYPE_SUBTITLE:
2873
            if(subtitle_disable)
2874
                ic->streams[i]->discard = AVDISCARD_ALL;
2875
            break;
2876
        case CODEC_TYPE_ATTACHMENT:
2877
        case CODEC_TYPE_UNKNOWN:
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
    rate_emu = 0;
2897
    av_freep(&video_codec_name);
2898
    av_freep(&audio_codec_name);
2899
    av_freep(&subtitle_codec_name);
2900
}
2901

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

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

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

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

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

    
2957
    video_enc = st->codec;
2958

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

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

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

    
2983
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2984
        if (video_codec_name)
2985
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2986

    
2987
        video_enc->codec_id = codec_id;
2988
        codec = avcodec_find_encoder(codec_id);
2989

    
2990
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2991

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

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

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

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

    
3021
        if(intra_matrix)
3022
            video_enc->intra_matrix = intra_matrix;
3023
        if(inter_matrix)
3024
            video_enc->inter_matrix = inter_matrix;
3025

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

    
3057
        if (do_psnr)
3058
            video_enc->flags|= CODEC_FLAG_PSNR;
3059

    
3060
        /* two pass mode */
3061
        if (do_pass) {
3062
            if (do_pass == 1) {
3063
                video_enc->flags |= CODEC_FLAG_PASS1;
3064
            } else {
3065
                video_enc->flags |= CODEC_FLAG_PASS2;
3066
            }
3067
        }
3068
    }
3069

    
3070
    /* reset some key parameters */
3071
    video_disable = 0;
3072
    av_freep(&video_codec_name);
3073
    video_stream_copy = 0;
3074
}
3075

    
3076
static void new_audio_stream(AVFormatContext *oc)
3077
{
3078
    AVStream *st;
3079
    AVCodecContext *audio_enc;
3080
    int codec_id;
3081

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

    
3089
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3090
    audio_bitstream_filters= NULL;
3091

    
3092
    if(thread_count>1)
3093
        avcodec_thread_init(st->codec, thread_count);
3094

    
3095
    audio_enc = st->codec;
3096
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3097

    
3098
    if(audio_codec_tag)
3099
        audio_enc->codec_tag= audio_codec_tag;
3100

    
3101
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3102
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3103
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3104
    }
3105
    if (audio_stream_copy) {
3106
        st->stream_copy = 1;
3107
        audio_enc->channels = audio_channels;
3108
    } else {
3109
        AVCodec *codec;
3110
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3111

    
3112
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3113

    
3114
        if (audio_codec_name)
3115
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3116
        audio_enc->codec_id = codec_id;
3117
        codec = avcodec_find_encoder(codec_id);
3118

    
3119
        if (audio_qscale > QSCALE_NONE) {
3120
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3121
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3122
        }
3123
        audio_enc->thread_count = thread_count;
3124
        audio_enc->channels = audio_channels;
3125
        audio_enc->sample_fmt = audio_sample_fmt;
3126

    
3127
        if(codec && codec->sample_fmts){
3128
            const enum SampleFormat *p= codec->sample_fmts;
3129
            for(; *p!=-1; p++){
3130
                if(*p == audio_enc->sample_fmt)
3131
                    break;
3132
            }
3133
            if(*p == -1)
3134
                audio_enc->sample_fmt = codec->sample_fmts[0];
3135
        }
3136
    }
3137
    audio_enc->sample_rate = audio_sample_rate;
3138
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3139
    if (audio_language) {
3140
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3141
        av_free(audio_language);
3142
        audio_language = NULL;
3143
    }
3144

    
3145
    /* reset some key parameters */
3146
    audio_disable = 0;
3147
    av_freep(&audio_codec_name);
3148
    audio_stream_copy = 0;
3149
}
3150

    
3151
static void new_subtitle_stream(AVFormatContext *oc)
3152
{
3153
    AVStream *st;
3154
    AVCodecContext *subtitle_enc;
3155

    
3156
    st = av_new_stream(oc, oc->nb_streams);
3157
    if (!st) {
3158
        fprintf(stderr, "Could not alloc stream\n");
3159
        av_exit(1);
3160
    }
3161
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3162

    
3163
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3164
    subtitle_bitstream_filters= NULL;
3165

    
3166
    subtitle_enc = st->codec;
3167
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3168
    if (subtitle_stream_copy) {
3169
        st->stream_copy = 1;
3170
    } else {
3171
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3172
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3173
    }
3174

    
3175
    if (subtitle_language) {
3176
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3177
        av_free(subtitle_language);
3178
        subtitle_language = NULL;
3179
    }
3180

    
3181
    subtitle_disable = 0;
3182
    av_freep(&subtitle_codec_name);
3183
    subtitle_stream_copy = 0;
3184
}
3185

    
3186
static void opt_new_audio_stream(void)
3187
{
3188
    AVFormatContext *oc;
3189
    if (nb_output_files <= 0) {
3190
        fprintf(stderr, "At least one output file must be specified\n");
3191
        av_exit(1);
3192
    }
3193
    oc = output_files[nb_output_files - 1];
3194
    new_audio_stream(oc);
3195
}
3196

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

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

    
3219
static void opt_output_file(const char *filename)
3220
{
3221
    AVFormatContext *oc;
3222
    int use_video, use_audio, use_subtitle;
3223
    int input_has_video, input_has_audio, input_has_subtitle;
3224
    AVFormatParameters params, *ap = &params;
3225

    
3226
    if (!strcmp(filename, "-"))
3227
        filename = "pipe:";
3228

    
3229
    oc = av_alloc_format_context();
3230

    
3231
    if (!file_oformat) {
3232
        file_oformat = guess_format(NULL, filename, NULL);
3233
        if (!file_oformat) {
3234
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3235
                    filename);
3236
            av_exit(1);
3237
        }
3238
    }
3239

    
3240
    oc->oformat = file_oformat;
3241
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3242

    
3243
    if (!strcmp(file_oformat->name, "ffm") &&
3244
        av_strstart(filename, "http:", NULL)) {
3245
        /* special case for files sent to ffserver: we get the stream
3246
           parameters from ffserver */
3247
        int err = read_ffserver_streams(oc, filename);
3248
        if (err < 0) {
3249
            print_error(filename, err);
3250
            av_exit(1);
3251
        }
3252
    } else {
3253
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3254
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3255
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3256

    
3257
        /* disable if no corresponding type found and at least one
3258
           input file */
3259
        if (nb_input_files > 0) {
3260
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3261
                                         &input_has_subtitle);
3262
            if (!input_has_video)
3263
                use_video = 0;
3264
            if (!input_has_audio)
3265
                use_audio = 0;
3266
            if (!input_has_subtitle)
3267
                use_subtitle = 0;
3268
        }
3269

    
3270
        /* manual disable */
3271
        if (audio_disable) {
3272
            use_audio = 0;
3273
        }
3274
        if (video_disable) {
3275
            use_video = 0;
3276
        }
3277
        if (subtitle_disable) {
3278
            use_subtitle = 0;
3279
        }
3280

    
3281
        if (use_video) {
3282
            new_video_stream(oc);
3283
        }
3284

    
3285
        if (use_audio) {
3286
            new_audio_stream(oc);
3287
        }
3288

    
3289
        if (use_subtitle) {
3290
            new_subtitle_stream(oc);
3291
        }
3292

    
3293
        oc->timestamp = rec_timestamp;
3294

    
3295
        if (str_title)
3296
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3297
        if (str_author)
3298
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3299
        if (str_copyright)
3300
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3301
        if (str_comment)
3302
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3303
        if (str_album)
3304
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3305
        if (str_genre)
3306
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3307
    }
3308

    
3309
    output_files[nb_output_files++] = oc;
3310

    
3311
    /* check filename in case of an image number is expected */
3312
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3313
        if (!av_filename_number_test(oc->filename)) {
3314
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3315
            av_exit(1);
3316
        }
3317
    }
3318

    
3319
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3320
        /* test if it already exists to avoid loosing precious files */
3321
        if (!file_overwrite &&
3322
            (strchr(filename, ':') == NULL ||
3323
             filename[1] == ':' ||
3324
             av_strstart(filename, "file:", NULL))) {
3325
            if (url_exist(filename)) {
3326
                int c;
3327

    
3328
                if (!using_stdin) {
3329
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3330
                    fflush(stderr);
3331
                    c = getchar();
3332
                    if (toupper(c) != 'Y') {
3333
                        fprintf(stderr, "Not overwriting - exiting\n");
3334
                        av_exit(1);
3335
                    }
3336
                }
3337
                else {
3338
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3339
                    av_exit(1);
3340
                }
3341
            }
3342
        }
3343

    
3344
        /* open the file */
3345
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3346
            fprintf(stderr, "Could not open '%s'\n", filename);
3347
            av_exit(1);
3348
        }
3349
    }
3350

    
3351
    memset(ap, 0, sizeof(*ap));
3352
    if (av_set_parameters(oc, ap) < 0) {
3353
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3354
                oc->filename);
3355
        av_exit(1);
3356
    }
3357

    
3358
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3359
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3360
    oc->loop_output = loop_output;
3361

    
3362
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3363

    
3364
    /* reset some options */
3365
    file_oformat = NULL;
3366
    file_iformat = NULL;
3367
}
3368

    
3369
/* same option as mencoder */
3370
static void opt_pass(const char *pass_str)
3371
{
3372
    int pass;
3373
    pass = atoi(pass_str);
3374
    if (pass != 1 && pass != 2) {
3375
        fprintf(stderr, "pass number can be only 1 or 2\n");
3376
        av_exit(1);
3377
    }
3378
    do_pass = pass;
3379
}
3380

    
3381
static int64_t getutime(void)
3382
{
3383
#ifdef HAVE_GETRUSAGE
3384
    struct rusage rusage;
3385

    
3386
    getrusage(RUSAGE_SELF, &rusage);
3387
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3388
#elif defined(HAVE_GETPROCESSTIMES)
3389
    HANDLE proc;
3390
    FILETIME c, e, k, u;
3391
    proc = GetCurrentProcess();
3392
    GetProcessTimes(proc, &c, &e, &k, &u);
3393
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3394
#else
3395
    return av_gettime();
3396
#endif
3397
}
3398

    
3399
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3400
{
3401
    int i;
3402
    const char *p = str;
3403
    for(i = 0;; i++) {
3404
        dest[i] = atoi(p);
3405
        if(i == 63)
3406
            break;
3407
        p = strchr(p, ',');
3408
        if(!p) {
3409
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3410
            av_exit(1);
3411
        }
3412
        p++;
3413
    }
3414
}
3415

    
3416
static void opt_inter_matrix(const char *arg)
3417
{
3418
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3419
    parse_matrix_coeffs(inter_matrix, arg);
3420
}
3421

    
3422
static void opt_intra_matrix(const char *arg)
3423
{
3424
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3425
    parse_matrix_coeffs(intra_matrix, arg);
3426
}
3427

    
3428
/**
3429
 * Trivial log callback.
3430
 * Only suitable for show_help and similar since it lacks prefix handling.
3431
 */
3432
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3433
{
3434
    vfprintf(stdout, fmt, vl);
3435
}
3436

    
3437
static void show_help(void)
3438
{
3439
    av_log_set_callback(log_callback_help);
3440
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3441
           "Hyper fast Audio and Video encoder\n");
3442
    printf("\n");
3443
    show_help_options(options, "Main options:\n",
3444
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3445
    show_help_options(options, "\nAdvanced options:\n",
3446
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3447
                      OPT_EXPERT);
3448
    show_help_options(options, "\nVideo options:\n",
3449
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3450
                      OPT_VIDEO);
3451
    show_help_options(options, "\nAdvanced Video options:\n",
3452
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3453
                      OPT_VIDEO | OPT_EXPERT);
3454
    show_help_options(options, "\nAudio options:\n",
3455
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3456
                      OPT_AUDIO);
3457
    show_help_options(options, "\nAdvanced Audio options:\n",
3458
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3459
                      OPT_AUDIO | OPT_EXPERT);
3460
    show_help_options(options, "\nSubtitle options:\n",
3461
                      OPT_SUBTITLE | OPT_GRAB,
3462
                      OPT_SUBTITLE);
3463
    show_help_options(options, "\nAudio/Video grab options:\n",
3464
                      OPT_GRAB,
3465
                      OPT_GRAB);
3466
    printf("\n");
3467
    av_opt_show(avctx_opts[0], NULL);
3468
    printf("\n");
3469
    av_opt_show(avformat_opts, NULL);
3470
    printf("\n");
3471
    av_opt_show(sws_opts, NULL);
3472
}
3473

    
3474
static void opt_target(const char *arg)
3475
{
3476
    int norm = -1;
3477
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3478

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

    
3523
    if(norm < 0) {
3524
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3525
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3526
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3527
        av_exit(1);
3528
    }
3529

    
3530
    if(!strcmp(arg, "vcd")) {
3531

    
3532
        opt_video_codec("mpeg1video");
3533
        opt_audio_codec("mp2");
3534
        opt_format("vcd");
3535

    
3536
        opt_frame_size(norm ? "352x240" : "352x288");
3537
        opt_frame_rate(NULL, frame_rates[norm]);
3538
        opt_default("gop", norm ? "18" : "15");
3539

    
3540
        opt_default("b", "1150000");
3541
        opt_default("maxrate", "1150000");
3542
        opt_default("minrate", "1150000");
3543
        opt_default("bufsize", "327680"); // 40*1024*8;
3544

    
3545
        opt_default("ab", "224000");
3546
        audio_sample_rate = 44100;
3547
        audio_channels = 2;
3548

    
3549
        opt_default("packetsize", "2324");
3550
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3551

    
3552
        /* We have to offset the PTS, so that it is consistent with the SCR.
3553
           SCR starts at 36000, but the first two packs contain only padding
3554
           and the first pack from the other stream, respectively, may also have
3555
           been written before.
3556
           So the real data starts at SCR 36000+3*1200. */
3557
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3558
    } else if(!strcmp(arg, "svcd")) {
3559

    
3560
        opt_video_codec("mpeg2video");
3561
        opt_audio_codec("mp2");
3562
        opt_format("svcd");
3563

    
3564
        opt_frame_size(norm ? "480x480" : "480x576");
3565
        opt_frame_rate(NULL, frame_rates[norm]);
3566
        opt_default("gop", norm ? "18" : "15");
3567

    
3568
        opt_default("b", "2040000");
3569
        opt_default("maxrate", "2516000");
3570
        opt_default("minrate", "0"); //1145000;
3571
        opt_default("bufsize", "1835008"); //224*1024*8;
3572
        opt_default("flags", "+scan_offset");
3573

    
3574

    
3575
        opt_default("ab", "224000");
3576
        audio_sample_rate = 44100;
3577

    
3578
        opt_default("packetsize", "2324");
3579

    
3580
    } else if(!strcmp(arg, "dvd")) {
3581

    
3582
        opt_video_codec("mpeg2video");
3583
        opt_audio_codec("ac3");
3584
        opt_format("dvd");
3585

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

    
3590
        opt_default("b", "6000000");
3591
        opt_default("maxrate", "9000000");
3592
        opt_default("minrate", "0"); //1500000;
3593
        opt_default("bufsize", "1835008"); //224*1024*8;
3594

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

    
3598
        opt_default("ab", "448000");
3599
        audio_sample_rate = 48000;
3600

    
3601
    } else if(!strncmp(arg, "dv", 2)) {
3602

    
3603
        opt_format("dv");
3604

    
3605
        opt_frame_size(norm ? "720x480" : "720x576");
3606
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3607
                                             (norm ? "yuv411p" : "yuv420p"));
3608
        opt_frame_rate(NULL, frame_rates[norm]);
3609

    
3610
        audio_sample_rate = 48000;
3611
        audio_channels = 2;
3612

    
3613
    } else {
3614
        fprintf(stderr, "Unknown target: %s\n", arg);
3615
        av_exit(1);
3616
    }
3617
}
3618

    
3619
static void opt_vstats_file (const char *arg)
3620
{
3621
    av_free (vstats_filename);
3622
    vstats_filename=av_strdup (arg);
3623
}
3624

    
3625
static void opt_vstats (void)
3626
{
3627
    char filename[40];
3628
    time_t today2 = time(NULL);
3629
    struct tm *today = localtime(&today2);
3630

    
3631
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3632
             today->tm_sec);
3633
    opt_vstats_file(filename);
3634
}
3635

    
3636
static int opt_bsf(const char *opt, const char *arg)
3637
{
3638
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3639
    AVBitStreamFilterContext **bsfp;
3640

    
3641
    if(!bsfc){
3642
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3643
        av_exit(1);
3644
    }
3645

    
3646
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3647
          *opt == 'a' ? &audio_bitstream_filters :
3648
                        &subtitle_bitstream_filters;
3649
    while(*bsfp)
3650
        bsfp= &(*bsfp)->next;
3651

    
3652
    *bsfp= bsfc;
3653

    
3654
    return 0;
3655
}
3656

    
3657
static int opt_preset(const char *opt, const char *arg)
3658
{
3659
    FILE *f=NULL;
3660
    char tmp[1000], tmp2[1000], line[1000];
3661
    int i;
3662
    const char *base[3]= { getenv("HOME"),
3663
                           "/usr/local/share",
3664
                           "/usr/share",
3665
                         };
3666

    
3667
    for(i=!base[0]; i<3 && !f; i++){
3668
        snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3669
        f= fopen(tmp, "r");
3670
        if(!f){
3671
            char *codec_name= *opt == 'v' ? video_codec_name :
3672
                              *opt == 'a' ? audio_codec_name :
3673
                                            subtitle_codec_name;
3674
              snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3675
            f= fopen(tmp, "r");
3676
        }
3677
    }
3678
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/')){
3679
        f= fopen(arg, "r");
3680
    }
3681

    
3682
    if(!f){
3683
        fprintf(stderr, "Preset file not found\n");
3684
        av_exit(1);
3685
    }
3686

    
3687
    while(!feof(f)){
3688
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3689
        if(line[0] == '#' && !e)
3690
            continue;
3691
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3692
        if(e){
3693
            fprintf(stderr, "Preset file invalid\n");
3694
            av_exit(1);
3695
        }
3696
        if(!strcmp(tmp, "acodec")){
3697
            opt_audio_codec(tmp2);
3698
        }else if(!strcmp(tmp, "vcodec")){
3699
            opt_video_codec(tmp2);
3700
        }else if(!strcmp(tmp, "scodec")){
3701
            opt_subtitle_codec(tmp2);
3702
        }else
3703
            opt_default(tmp, tmp2);
3704
    }
3705

    
3706
    fclose(f);
3707

    
3708
    return 0;
3709
}
3710

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

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

    
3802
    /* audio options */
3803
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3804
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3805
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3806
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3807
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3808
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3809
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3810
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3811
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3812
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3813
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3814
    { "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" },
3815

    
3816
    /* subtitle options */
3817
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3818
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3819
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3820
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3821

    
3822
    /* grab options */
3823
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3824
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3825
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3826

    
3827
    /* muxer options */
3828
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3829
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3830

    
3831
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3832
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3833
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3834

    
3835
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3836
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3837
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3838

    
3839
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3840
    { NULL, },
3841
};
3842

    
3843
int main(int argc, char **argv)
3844
{
3845
    int i;
3846
    int64_t ti;
3847

    
3848
    avcodec_register_all();
3849
    avdevice_register_all();
3850
    av_register_all();
3851

    
3852
    if(isatty(STDIN_FILENO))
3853
        url_set_interrupt_cb(decode_interrupt_cb);
3854

    
3855
    for(i=0; i<CODEC_TYPE_NB; i++){
3856
        avctx_opts[i]= avcodec_alloc_context2(i);
3857
    }
3858
    avformat_opts = av_alloc_format_context();
3859
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3860

    
3861
    show_banner();
3862
    if (argc <= 1) {
3863
        show_help();
3864
        av_exit(1);
3865
    }
3866

    
3867
    /* parse options */
3868
    parse_options(argc, argv, options, opt_output_file);
3869

    
3870
    /* file converter / grab */
3871
    if (nb_output_files <= 0) {
3872
        fprintf(stderr, "Must supply at least one output file\n");
3873
        av_exit(1);
3874
    }
3875

    
3876
    if (nb_input_files == 0) {
3877
        fprintf(stderr, "Must supply at least one input file\n");
3878
        av_exit(1);
3879
    }
3880

    
3881
    ti = getutime();
3882
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3883
              stream_maps, nb_stream_maps);
3884
    ti = getutime() - ti;
3885
    if (do_benchmark) {
3886
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3887
    }
3888

    
3889
    return av_exit(0);
3890
}