Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 647148c6

History | View | Annotate | Download (138 KB)

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

    
22
/* needed for usleep() */
23
#define _XOPEN_SOURCE 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
#if defined(HAVE_TERMIOS_H)
52
#include <fcntl.h>
53
#include <sys/ioctl.h>
54
#include <sys/time.h>
55
#include <termios.h>
56
#elif defined(HAVE_CONIO_H)
57
#include <conio.h>
58
#endif
59
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
60
#include <time.h>
61

    
62
#include "cmdutils.h"
63

    
64
#undef NDEBUG
65
#include <assert.h>
66

    
67
#undef exit
68

    
69
const char program_name[] = "FFmpeg";
70
const int program_birth_year = 2000;
71

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

    
80
/** select an input file for an output file */
81
typedef struct AVMetaDataMap {
82
    int out_file;
83
    int in_file;
84
} AVMetaDataMap;
85

    
86
static const OptionDef options[];
87

    
88
#define MAX_FILES 20
89

    
90
static AVFormatContext *input_files[MAX_FILES];
91
static int64_t input_files_ts_offset[MAX_FILES];
92
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
93
static int nb_input_files = 0;
94

    
95
static AVFormatContext *output_files[MAX_FILES];
96
static int nb_output_files = 0;
97

    
98
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
99
static int nb_stream_maps;
100

    
101
static AVMetaDataMap meta_data_maps[MAX_FILES];
102
static int nb_meta_data_maps;
103

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

    
144
static int intra_only = 0;
145
static int audio_sample_rate = 44100;
146
#define QSCALE_NONE -99999
147
static float audio_qscale = QSCALE_NONE;
148
static int audio_disable = 0;
149
static int audio_channels = 1;
150
static char  *audio_codec_name = NULL;
151
static int audio_codec_tag = 0;
152
static char *audio_language = NULL;
153

    
154
static int subtitle_disable = 0;
155
static char *subtitle_codec_name = NULL;
156
static char *subtitle_language = NULL;
157

    
158
static float mux_preload= 0.5;
159
static float mux_max_delay= 0.7;
160

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

    
191
static int rate_emu = 0;
192

    
193
static int  video_channel = 0;
194
static char *video_standard;
195

    
196
static int audio_volume = 256;
197

    
198
static int using_stdin = 0;
199
static int using_vhook = 0;
200
static int verbose = 1;
201
static int thread_count= 1;
202
static int q_pressed = 0;
203
static int64_t video_size = 0;
204
static int64_t audio_size = 0;
205
static int64_t extra_size = 0;
206
static int nb_frames_dup = 0;
207
static int nb_frames_drop = 0;
208
static int input_sync;
209
static uint64_t limit_filesize = 0; //
210

    
211
static int pgmyuv_compatibility_hack=0;
212
static float dts_delta_threshold = 10;
213

    
214
static unsigned int sws_flags = SWS_BICUBIC;
215

    
216
static const char **opt_names;
217
static int opt_name_count;
218
static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
219
static AVFormatContext *avformat_opts;
220
static struct SwsContext *sws_opts;
221
static int64_t timer_start;
222

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

    
228
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
229

    
230
struct AVInputStream;
231

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

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

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

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

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

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

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

    
292
#ifdef HAVE_TERMIOS_H
293

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

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

    
305
static volatile sig_atomic_t received_sigterm = 0;
306

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
408
    av_free(opt_names);
409

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

    
414
    av_free(video_standard);
415

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
501
        bsfc= bsfc->next;
502
    }
503

    
504
    ret= av_interleaved_write_frame(s, pkt);
505
    if(ret < 0){
506
        print_error("av_interleaved_write_frame()", ret);
507
        av_exit(1);
508
    }
509
}
510

    
511
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
512

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

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

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

    
538
    if (enc->channels != dec->channels)
539
        ost->audio_resample = 1;
540

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

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

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

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

    
598
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
599
                        ist->is_start=0;
600
                    else
601
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
602

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

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

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

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

    
657
        frame_bytes = enc->frame_size * osize * enc->channels;
658

    
659
        while (av_fifo_size(&ost->fifo) >= frame_bytes) {
660
            AVPacket pkt;
661
            av_init_packet(&pkt);
662

    
663
            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
664

    
665
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
666

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

    
678
            ost->sync_opts += enc->frame_size;
679
        }
680
    } else {
681
        AVPacket pkt;
682
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
683
        av_init_packet(&pkt);
684

    
685
        ost->sync_opts += size_out / (osize * enc->channels);
686

    
687
        /* output a pcm frame */
688
        /* determine the size of the coded buffer */
689
        size_out /= osize;
690
        if (coded_bps)
691
            size_out *= coded_bps;
692

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

    
707
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
708
{
709
    AVCodecContext *dec;
710
    AVPicture *picture2;
711
    AVPicture picture_tmp;
712
    uint8_t *buf = 0;
713

    
714
    dec = ist->st->codec;
715

    
716
    /* deinterlace : must be done before any resize */
717
    if (do_deinterlace || using_vhook) {
718
        int size;
719

    
720
        /* create temporary picture */
721
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
722
        buf = av_malloc(size);
723
        if (!buf)
724
            return;
725

    
726
        picture2 = &picture_tmp;
727
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
728

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

    
745
    if (ENABLE_VHOOK)
746
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
747
                           1000000 * ist->pts / AV_TIME_BASE);
748

    
749
    if (picture != picture2)
750
        *picture = *picture2;
751
    *bufp = buf;
752
}
753

    
754
/* we begin to correct av delay at this threshold */
755
#define AV_DELAY_MAX 0.100
756

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

    
769
    if (pts == AV_NOPTS_VALUE) {
770
        fprintf(stderr, "Subtitle packets must have a pts\n");
771
        return;
772
    }
773

    
774
    enc = ost->st->codec;
775

    
776
    if (!subtitle_out) {
777
        subtitle_out = av_malloc(subtitle_out_max_size);
778
    }
779

    
780
    /* Note: DVB subtitle need one packet to draw them and one other
781
       packet to clear them */
782
    /* XXX: signal it in the codec context ? */
783
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
784
        nb = 2;
785
    else
786
        nb = 1;
787

    
788
    for(i = 0; i < nb; i++) {
789
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
790
                                                    subtitle_out_max_size, sub);
791

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

    
809
static int bit_buffer_size= 1024*256;
810
static uint8_t *bit_buffer= NULL;
811

    
812
static void do_video_out(AVFormatContext *s,
813
                         AVOutputStream *ost,
814
                         AVInputStream *ist,
815
                         AVFrame *in_picture,
816
                         int *frame_size)
817
{
818
    int nb_frames, i, ret;
819
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
820
    AVFrame picture_crop_temp, picture_pad_temp;
821
    AVCodecContext *enc, *dec;
822

    
823
    avcodec_get_frame_defaults(&picture_crop_temp);
824
    avcodec_get_frame_defaults(&picture_pad_temp);
825

    
826
    enc = ost->st->codec;
827
    dec = ist->st->codec;
828

    
829
    /* by default, we output a single frame */
830
    nb_frames = 1;
831

    
832
    *frame_size = 0;
833

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

    
857
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
858
    if (nb_frames <= 0)
859
        return;
860

    
861
    if (ost->video_crop) {
862
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
863
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
864
            return;
865
        }
866
        formatted_picture = &picture_crop_temp;
867
    } else {
868
        formatted_picture = in_picture;
869
    }
870

    
871
    final_picture = formatted_picture;
872
    padding_src = formatted_picture;
873
    resampling_dst = &ost->pict_tmp;
874
    if (ost->video_pad) {
875
        final_picture = &ost->pict_tmp;
876
        if (ost->video_resample) {
877
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
878
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
879
                return;
880
            }
881
            resampling_dst = &picture_pad_temp;
882
        }
883
    }
884

    
885
    if (ost->video_resample) {
886
        padding_src = NULL;
887
        final_picture = &ost->pict_tmp;
888
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
889
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
890
    }
891

    
892
    if (ost->video_pad) {
893
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
894
                enc->height, enc->width, enc->pix_fmt,
895
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
896
    }
897

    
898
    /* duplicates frame if needed */
899
    for(i=0;i<nb_frames;i++) {
900
        AVPacket pkt;
901
        av_init_packet(&pkt);
902
        pkt.stream_index= ost->index;
903

    
904
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
905
            /* raw pictures are written as AVPicture structure to
906
               avoid any copies. We support temorarily the older
907
               method. */
908
            AVFrame* old_frame = enc->coded_frame;
909
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
910
            pkt.data= (uint8_t *)final_picture;
911
            pkt.size=  sizeof(AVPicture);
912
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
913
            pkt.flags |= PKT_FLAG_KEY;
914

    
915
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
916
            enc->coded_frame = old_frame;
917
        } else {
918
            AVFrame big_picture;
919

    
920
            big_picture= *final_picture;
921
            /* better than nothing: use input picture interlaced
922
               settings */
923
            big_picture.interlaced_frame = in_picture->interlaced_frame;
924
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
925
                if(top_field_first == -1)
926
                    big_picture.top_field_first = in_picture->top_field_first;
927
                else
928
                    big_picture.top_field_first = top_field_first;
929
            }
930

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

    
960
                if(enc->coded_frame->key_frame)
961
                    pkt.flags |= PKT_FLAG_KEY;
962
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
963
                *frame_size = ret;
964
                video_size += ret;
965
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
966
                //        enc->frame_number-1, enc->real_pict_num, ret,
967
                //        enc->pict_type);
968
                /* if two pass, output log */
969
                if (ost->logfile && enc->stats_out) {
970
                    fprintf(ost->logfile, "%s", enc->stats_out);
971
                }
972
            }
973
        }
974
        ost->sync_opts++;
975
        ost->frame_number++;
976
    }
977
}
978

    
979
static double psnr(double d){
980
    return -10.0*log(d)/log(10.0);
981
}
982

    
983
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
984
                           int frame_size)
985
{
986
    AVCodecContext *enc;
987
    int frame_number;
988
    double ti1, bitrate, avg_bitrate;
989

    
990
    /* this is executed just the first time do_video_stats is called */
991
    if (!vstats_file) {
992
        vstats_file = fopen(vstats_filename, "w");
993
        if (!vstats_file) {
994
            perror("fopen");
995
            av_exit(1);
996
        }
997
    }
998

    
999
    enc = ost->st->codec;
1000
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1001
        frame_number = ost->frame_number;
1002
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1003
        if (enc->flags&CODEC_FLAG_PSNR)
1004
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1005

    
1006
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1007
        /* compute pts value */
1008
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1009
        if (ti1 < 0.01)
1010
            ti1 = 0.01;
1011

    
1012
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1013
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1014
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1015
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1016
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1017
    }
1018
}
1019

    
1020
static void print_report(AVFormatContext **output_files,
1021
                         AVOutputStream **ost_table, int nb_ostreams,
1022
                         int is_last_report)
1023
{
1024
    char buf[1024];
1025
    AVOutputStream *ost;
1026
    AVFormatContext *oc, *os;
1027
    int64_t total_size;
1028
    AVCodecContext *enc;
1029
    int frame_number, vid, i;
1030
    double bitrate, ti1, pts;
1031
    static int64_t last_time = -1;
1032
    static int qp_histogram[52];
1033

    
1034
    if (!is_last_report) {
1035
        int64_t cur_time;
1036
        /* display the report every 0.5 seconds */
1037
        cur_time = av_gettime();
1038
        if (last_time == -1) {
1039
            last_time = cur_time;
1040
            return;
1041
        }
1042
        if ((cur_time - last_time) < 500000)
1043
            return;
1044
        last_time = cur_time;
1045
    }
1046

    
1047

    
1048
    oc = output_files[0];
1049

    
1050
    total_size = url_fsize(oc->pb);
1051
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1052
        total_size= url_ftell(oc->pb);
1053

    
1054
    buf[0] = '\0';
1055
    ti1 = 1e10;
1056
    vid = 0;
1057
    for(i=0;i<nb_ostreams;i++) {
1058
        ost = ost_table[i];
1059
        os = output_files[ost->file_index];
1060
        enc = ost->st->codec;
1061
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1062
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1063
                     !ost->st->stream_copy ?
1064
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1065
        }
1066
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1067
            float t = (av_gettime()-timer_start) / 1000000.0;
1068

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

    
1115
    if (verbose || is_last_report) {
1116
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1117

    
1118
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1119
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1120
            (double)total_size / 1024, ti1, bitrate);
1121

    
1122
        if (verbose > 1)
1123
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1124
                  nb_frames_dup, nb_frames_drop);
1125

    
1126
        if (verbose >= 0)
1127
            fprintf(stderr, "%s    \r", buf);
1128

    
1129
        fflush(stderr);
1130
    }
1131

    
1132
    if (is_last_report && verbose >= 0){
1133
        int64_t raw= audio_size + video_size + extra_size;
1134
        fprintf(stderr, "\n");
1135
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1136
                video_size/1024.0,
1137
                audio_size/1024.0,
1138
                extra_size/1024.0,
1139
                100.0*(total_size - raw)/raw
1140
        );
1141
    }
1142
}
1143

    
1144
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1145
static int output_packet(AVInputStream *ist, int ist_index,
1146
                         AVOutputStream **ost_table, int nb_ostreams,
1147
                         const AVPacket *pkt)
1148
{
1149
    AVFormatContext *os;
1150
    AVOutputStream *ost;
1151
    uint8_t *ptr;
1152
    int len, ret, i;
1153
    uint8_t *data_buf;
1154
    int data_size, got_picture;
1155
    AVFrame picture;
1156
    void *buffer_to_free;
1157
    static unsigned int samples_size= 0;
1158
    static short *samples= NULL;
1159
    AVSubtitle subtitle, *subtitle_to_free;
1160
    int got_subtitle;
1161

    
1162
    if(ist->next_pts == AV_NOPTS_VALUE)
1163
        ist->next_pts= ist->pts;
1164

    
1165
    if (pkt == NULL) {
1166
        /* EOF handling */
1167
        ptr = NULL;
1168
        len = 0;
1169
        goto handle_eof;
1170
    }
1171

    
1172
    if(pkt->dts != AV_NOPTS_VALUE)
1173
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1174

    
1175
    len = pkt->size;
1176
    ptr = pkt->data;
1177

    
1178
    //while we have more to decode or while the decoder did output something on EOF
1179
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1180
    handle_eof:
1181
        ist->pts= ist->next_pts;
1182

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

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

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

    
1272
        buffer_to_free = NULL;
1273
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1274
            pre_process_video_frame(ist, (AVPicture *)&picture,
1275
                                    &buffer_to_free);
1276
        }
1277

    
1278
        // preprocess audio (volume)
1279
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1280
            if (audio_volume != 256) {
1281
                short *volp;
1282
                volp = samples;
1283
                for(i=0;i<(data_size / sizeof(short));i++) {
1284
                    int v = ((*volp) * audio_volume + 128) >> 8;
1285
                    if (v < -32768) v = -32768;
1286
                    if (v >  32767) v = 32767;
1287
                    *volp++ = v;
1288
                }
1289
            }
1290
        }
1291

    
1292
        /* frame rate emulation */
1293
        if (ist->st->codec->rate_emu) {
1294
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1295
            int64_t now = av_gettime() - ist->start;
1296
            if (pts > now)
1297
                usleep(pts - now);
1298

    
1299
            ist->frame++;
1300
        }
1301

    
1302
#if 0
1303
        /* mpeg PTS deordering : if it is a P or I frame, the PTS
1304
           is the one of the next displayed one */
1305
        /* XXX: add mpeg4 too ? */
1306
        if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1307
            if (ist->st->codec->pict_type != B_TYPE) {
1308
                int64_t tmp;
1309
                tmp = ist->last_ip_pts;
1310
                ist->last_ip_pts  = ist->frac_pts.val;
1311
                ist->frac_pts.val = tmp;
1312
            }
1313
        }
1314
#endif
1315
        /* if output time reached then transcode raw format,
1316
           encode packets and output them */
1317
        if (start_time == 0 || ist->pts >= start_time)
1318
            for(i=0;i<nb_ostreams;i++) {
1319
                int frame_size;
1320

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1478
    return 0;
1479
 fail_decode:
1480
    return -1;
1481
}
1482

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

    
1487
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1488
    printf("SDP:\n%s\n", sdp);
1489
}
1490

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

    
1514
    return -1;
1515
}
1516

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

    
1535
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1536
    if (!file_table)
1537
        goto fail;
1538

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

    
1549
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1550
    if (!ist_table)
1551
        goto fail;
1552

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

    
1570
            if (ist->st->codec->rate_emu) {
1571
                ist->start = av_gettime();
1572
                ist->frame = 0;
1573
            }
1574
        }
1575
    }
1576

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

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

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

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

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

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

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

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

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

    
1700
        codec = ost->st->codec;
1701
        icodec = ist->st->codec;
1702

    
1703
        if (!ost->st->language[0])
1704
            av_strlcpy(ost->st->language, ist->st->language,
1705
                       sizeof(ost->st->language));
1706

    
1707
        ost->st->disposition = ist->st->disposition;
1708

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

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

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

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

    
1874
    if (!bit_buffer)
1875
        bit_buffer = av_malloc(bit_buffer_size);
1876
    if (!bit_buffer)
1877
        goto fail;
1878

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

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

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

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

    
1944
    /* init pts */
1945
    for(i=0;i<nb_istreams;i++) {
1946
        ist = ist_table[i];
1947
        is = input_files[ist->file_index];
1948
        ist->pts = 0;
1949
        ist->next_pts = AV_NOPTS_VALUE;
1950
        ist->is_start = 1;
1951
    }
1952

    
1953
    /* set meta data information from input file if required */
1954
    for (i=0;i<nb_meta_data_maps;i++) {
1955
        AVFormatContext *out_file;
1956
        AVFormatContext *in_file;
1957

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

    
1971
        out_file = output_files[out_file_index];
1972
        in_file = input_files[in_file_index];
1973

    
1974
        strcpy(out_file->title, in_file->title);
1975
        strcpy(out_file->author, in_file->author);
1976
        strcpy(out_file->copyright, in_file->copyright);
1977
        strcpy(out_file->comment, in_file->comment);
1978
        strcpy(out_file->album, in_file->album);
1979
        out_file->year = in_file->year;
1980
        out_file->track = in_file->track;
1981
        strcpy(out_file->genre, in_file->genre);
1982
    }
1983

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

    
2000
    if (!using_stdin && verbose >= 0) {
2001
        fprintf(stderr, "Press [q] to stop encoding\n");
2002
        url_set_interrupt_cb(decode_interrupt_cb);
2003
    }
2004
    term_init();
2005

    
2006
    key = -1;
2007
    timer_start = av_gettime();
2008

    
2009
    for(; received_sigterm == 0;) {
2010
        int file_index, ist_index;
2011
        AVPacket pkt;
2012
        double ipts_min;
2013
        double opts_min;
2014

    
2015
    redo:
2016
        ipts_min= 1e100;
2017
        opts_min= 1e100;
2018
        /* if 'q' pressed, exits */
2019
        if (!using_stdin) {
2020
            if (q_pressed)
2021
                break;
2022
            /* read_key() returns 0 on EOF */
2023
            key = read_key();
2024
            if (key == 'q')
2025
                break;
2026
        }
2027

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

    
2061
        /* finish if recording time exhausted */
2062
        if (opts_min >= (recording_time / 1000000.0))
2063
            break;
2064

    
2065
        /* finish if limit size exhausted */
2066
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2067
            break;
2068

    
2069
        /* read a frame from it and output it in the fifo */
2070
        is = input_files[file_index];
2071
        if (av_read_frame(is, &pkt) < 0) {
2072
            file_table[file_index].eof_reached = 1;
2073
            if (opt_shortest)
2074
                break;
2075
            else
2076
                continue;
2077
        }
2078

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

    
2091
        if (pkt.dts != AV_NOPTS_VALUE)
2092
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2093
        if (pkt.pts != AV_NOPTS_VALUE)
2094
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2095

    
2096
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2097
            if(pkt.pts != AV_NOPTS_VALUE)
2098
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2099
            if(pkt.dts != AV_NOPTS_VALUE)
2100
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2101
        }
2102

    
2103
//        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);
2104
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2105
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2106
            int64_t delta= pkt_dts - ist->next_pts;
2107
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2108
                input_files_ts_offset[ist->file_index]-= delta;
2109
                if (verbose > 2)
2110
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2111
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2112
                if(pkt.pts != AV_NOPTS_VALUE)
2113
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2114
            }
2115
        }
2116

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

    
2120
            if (verbose >= 0)
2121
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2122
                        ist->file_index, ist->index);
2123

    
2124
            av_free_packet(&pkt);
2125
            goto redo;
2126
        }
2127

    
2128
    discard_packet:
2129
        av_free_packet(&pkt);
2130

    
2131
        /* dump report by using the output first video and audio streams */
2132
        print_report(output_files, ost_table, nb_ostreams, 0);
2133
    }
2134

    
2135
    /* at the end of stream, we must flush the decoder buffers */
2136
    for(i=0;i<nb_istreams;i++) {
2137
        ist = ist_table[i];
2138
        if (ist->decoding_needed) {
2139
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2140
        }
2141
    }
2142

    
2143
    term_exit();
2144

    
2145
    /* write the trailer if needed and close file */
2146
    for(i=0;i<nb_output_files;i++) {
2147
        os = output_files[i];
2148
        av_write_trailer(os);
2149
    }
2150

    
2151
    /* dump report by using the first video and audio streams */
2152
    print_report(output_files, ost_table, nb_ostreams, 1);
2153

    
2154
    /* close each encoder */
2155
    for(i=0;i<nb_ostreams;i++) {
2156
        ost = ost_table[i];
2157
        if (ost->encoding_needed) {
2158
            av_freep(&ost->st->codec->stats_in);
2159
            avcodec_close(ost->st->codec);
2160
        }
2161
    }
2162

    
2163
    /* close each decoder */
2164
    for(i=0;i<nb_istreams;i++) {
2165
        ist = ist_table[i];
2166
        if (ist->decoding_needed) {
2167
            avcodec_close(ist->st->codec);
2168
        }
2169
    }
2170

    
2171
    /* finished ! */
2172

    
2173
    ret = 0;
2174
 fail1:
2175
    av_freep(&bit_buffer);
2176
    av_free(file_table);
2177

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

    
2213
#if 0
2214
int file_read(const char *filename)
2215
{
2216
    URLContext *h;
2217
    unsigned char buffer[1024];
2218
    int len, i;
2219

2220
    if (url_open(&h, filename, O_RDONLY) < 0) {
2221
        printf("could not open '%s'\n", filename);
2222
        return -1;
2223
    }
2224
    for(;;) {
2225
        len = url_read(h, buffer, sizeof(buffer));
2226
        if (len <= 0)
2227
            break;
2228
        for(i=0;i<len;i++) putchar(buffer[i]);
2229
    }
2230
    url_close(h);
2231
    return 0;
2232
}
2233
#endif
2234

    
2235
static void opt_format(const char *arg)
2236
{
2237
    /* compatibility stuff for pgmyuv */
2238
    if (!strcmp(arg, "pgmyuv")) {
2239
        pgmyuv_compatibility_hack=1;
2240
//        opt_image_format(arg);
2241
        arg = "image2";
2242
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2243
    }
2244

    
2245
    file_iformat = av_find_input_format(arg);
2246
    file_oformat = guess_format(arg, NULL, NULL);
2247
    if (!file_iformat && !file_oformat) {
2248
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2249
        av_exit(1);
2250
    }
2251
}
2252

    
2253
static int opt_default(const char *opt, const char *arg){
2254
    int type;
2255
    const AVOption *o= NULL;
2256
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2257

    
2258
    for(type=0; type<CODEC_TYPE_NB; type++){
2259
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2260
        if(o2)
2261
            o = av_set_string2(avctx_opts[type], opt, arg, 1);
2262
    }
2263
    if(!o)
2264
        o = av_set_string2(avformat_opts, opt, arg, 1);
2265
    if(!o)
2266
        o = av_set_string2(sws_opts, opt, arg, 1);
2267
    if(!o){
2268
        if(opt[0] == 'a')
2269
            o = av_set_string2(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1);
2270
        else if(opt[0] == 'v')
2271
            o = av_set_string2(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1);
2272
        else if(opt[0] == 's')
2273
            o = av_set_string2(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1);
2274
    }
2275
    if(!o)
2276
        return -1;
2277

    
2278
//    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
2279

    
2280
    //FIXME we should always use avctx_opts, ... for storing options so there will not be any need to keep track of what i set over this
2281
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2282
    opt_names[opt_name_count++]= o->name;
2283

    
2284
    if(avctx_opts[0]->debug || avformat_opts->debug)
2285
        av_log_set_level(AV_LOG_DEBUG);
2286
    return 0;
2287
}
2288

    
2289
static void opt_video_rc_override_string(const char *arg)
2290
{
2291
    video_rc_override_string = arg;
2292
}
2293

    
2294
static int opt_me_threshold(const char *opt, const char *arg)
2295
{
2296
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2297
    return 0;
2298
}
2299

    
2300
static int opt_verbose(const char *opt, const char *arg)
2301
{
2302
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2303
    av_log_set_level(verbose);
2304
    return 0;
2305
}
2306

    
2307
static int opt_frame_rate(const char *opt, const char *arg)
2308
{
2309
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2310
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2311
        av_exit(1);
2312
    }
2313
    return 0;
2314
}
2315

    
2316
static int opt_bitrate(const char *opt, const char *arg)
2317
{
2318
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2319

    
2320
    opt_default(opt, arg);
2321

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

    
2325
    return 0;
2326
}
2327

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

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

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

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

    
2400
static void opt_frame_size(const char *arg)
2401
{
2402
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2403
        fprintf(stderr, "Incorrect frame size\n");
2404
        av_exit(1);
2405
    }
2406
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2407
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2408
        av_exit(1);
2409
    }
2410
}
2411

    
2412

    
2413
#define SCALEBITS 10
2414
#define ONE_HALF  (1 << (SCALEBITS - 1))
2415
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2416

    
2417
#define RGB_TO_Y(r, g, b) \
2418
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2419
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2420

    
2421
#define RGB_TO_U(r1, g1, b1, shift)\
2422
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2423
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2424

    
2425
#define RGB_TO_V(r1, g1, b1, shift)\
2426
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2427
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2428

    
2429
static void opt_pad_color(const char *arg) {
2430
    /* Input is expected to be six hex digits similar to
2431
       how colors are expressed in html tags (but without the #) */
2432
    int rgb = strtol(arg, NULL, 16);
2433
    int r,g,b;
2434

    
2435
    r = (rgb >> 16);
2436
    g = ((rgb >> 8) & 255);
2437
    b = (rgb & 255);
2438

    
2439
    padcolor[0] = RGB_TO_Y(r,g,b);
2440
    padcolor[1] = RGB_TO_U(r,g,b,0);
2441
    padcolor[2] = RGB_TO_V(r,g,b,0);
2442
}
2443

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

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

    
2470

    
2471
static void opt_frame_pad_left(const char *arg)
2472
{
2473
    frame_padleft = atoi(arg);
2474
    if (frame_padleft < 0) {
2475
        fprintf(stderr, "Incorrect left pad size\n");
2476
        av_exit(1);
2477
    }
2478
    if ((frame_padleft % 2) != 0) {
2479
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2480
        av_exit(1);
2481
    }
2482
}
2483

    
2484

    
2485
static void opt_frame_pad_right(const char *arg)
2486
{
2487
    frame_padright = atoi(arg);
2488
    if (frame_padright < 0) {
2489
        fprintf(stderr, "Incorrect right pad size\n");
2490
        av_exit(1);
2491
    }
2492
    if ((frame_padright % 2) != 0) {
2493
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2494
        av_exit(1);
2495
    }
2496
}
2497

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

    
2508
static void opt_frame_pix_fmt(const char *arg)
2509
{
2510
    if (strcmp(arg, "list"))
2511
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2512
    else {
2513
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2514
        av_exit(0);
2515
    }
2516
}
2517

    
2518
static void opt_frame_aspect_ratio(const char *arg)
2519
{
2520
    int x = 0, y = 0;
2521
    double ar = 0;
2522
    const char *p;
2523
    char *end;
2524

    
2525
    p = strchr(arg, ':');
2526
    if (p) {
2527
        x = strtol(arg, &end, 10);
2528
        if (end == p)
2529
            y = strtol(end+1, &end, 10);
2530
        if (x > 0 && y > 0)
2531
            ar = (double)x / (double)y;
2532
    } else
2533
        ar = strtod(arg, NULL);
2534

    
2535
    if (!ar) {
2536
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2537
        av_exit(1);
2538
    }
2539
    frame_aspect_ratio = ar;
2540
}
2541

    
2542
static void opt_qscale(const char *arg)
2543
{
2544
    video_qscale = atof(arg);
2545
    if (video_qscale <= 0 ||
2546
        video_qscale > 255) {
2547
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2548
        av_exit(1);
2549
    }
2550
}
2551

    
2552
static void opt_top_field_first(const char *arg)
2553
{
2554
    top_field_first= atoi(arg);
2555
}
2556

    
2557
static int opt_thread_count(const char *opt, const char *arg)
2558
{
2559
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2560
#if !defined(HAVE_THREADS)
2561
    if (verbose >= 0)
2562
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2563
#endif
2564
    return 0;
2565
}
2566

    
2567
static void opt_audio_sample_fmt(const char *arg)
2568
{
2569
    if (strcmp(arg, "list"))
2570
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2571
    else {
2572
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2573
        av_exit(0);
2574
    }
2575
}
2576

    
2577
static int opt_audio_rate(const char *opt, const char *arg)
2578
{
2579
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2580
    return 0;
2581
}
2582

    
2583
static int opt_audio_channels(const char *opt, const char *arg)
2584
{
2585
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2586
    return 0;
2587
}
2588

    
2589
static void opt_video_channel(const char *arg)
2590
{
2591
    video_channel = strtol(arg, NULL, 0);
2592
}
2593

    
2594
static void opt_video_standard(const char *arg)
2595
{
2596
    video_standard = av_strdup(arg);
2597
}
2598

    
2599
static void opt_codec(int *pstream_copy, char **pcodec_name,
2600
                      int codec_type, const char *arg)
2601
{
2602
    av_freep(pcodec_name);
2603
    if (!strcmp(arg, "copy")) {
2604
        *pstream_copy = 1;
2605
    } else {
2606
        *pcodec_name = av_strdup(arg);
2607
    }
2608
}
2609

    
2610
static void opt_audio_codec(const char *arg)
2611
{
2612
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2613
}
2614

    
2615
static void opt_audio_tag(const char *arg)
2616
{
2617
    char *tail;
2618
    audio_codec_tag= strtol(arg, &tail, 0);
2619

    
2620
    if(!tail || *tail)
2621
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2622
}
2623

    
2624
static void opt_video_tag(const char *arg)
2625
{
2626
    char *tail;
2627
    video_codec_tag= strtol(arg, &tail, 0);
2628

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

    
2633
#ifdef CONFIG_VHOOK
2634
static void add_frame_hooker(const char *arg)
2635
{
2636
    int argc = 0;
2637
    char *argv[64];
2638
    int i;
2639
    char *args = av_strdup(arg);
2640

    
2641
    using_vhook = 1;
2642

    
2643
    argv[0] = strtok(args, " ");
2644
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2645
    }
2646

    
2647
    i = frame_hook_add(argc, argv);
2648

    
2649
    if (i != 0) {
2650
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2651
        av_exit(1);
2652
    }
2653
}
2654
#endif
2655

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

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

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

    
2671
    m = &stream_maps[nb_stream_maps++];
2672

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

    
2677
    m->stream_index = strtol(p, &p, 0);
2678
    if (*p) {
2679
        p++;
2680
        m->sync_file_index = strtol(p, &p, 0);
2681
        if (*p)
2682
            p++;
2683
        m->sync_stream_index = strtol(p, &p, 0);
2684
    } else {
2685
        m->sync_file_index = m->file_index;
2686
        m->sync_stream_index = m->stream_index;
2687
    }
2688
}
2689

    
2690
static void opt_map_meta_data(const char *arg)
2691
{
2692
    AVMetaDataMap *m;
2693
    char *p;
2694

    
2695
    m = &meta_data_maps[nb_meta_data_maps++];
2696

    
2697
    m->out_file = strtol(arg, &p, 0);
2698
    if (*p)
2699
        p++;
2700

    
2701
    m->in_file = strtol(p, &p, 0);
2702
}
2703

    
2704
static void opt_input_ts_scale(const char *arg)
2705
{
2706
    unsigned int stream;
2707
    double scale;
2708
    char *p;
2709

    
2710
    stream = strtol(arg, &p, 0);
2711
    if (*p)
2712
        p++;
2713
    scale= strtod(p, &p);
2714

    
2715
    if(stream >= MAX_STREAMS)
2716
        av_exit(1);
2717

    
2718
    input_files_ts_scale[nb_input_files][stream]= scale;
2719
}
2720

    
2721
static int opt_recording_time(const char *opt, const char *arg)
2722
{
2723
    recording_time = parse_time_or_die(opt, arg, 1);
2724
    return 0;
2725
}
2726

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

    
2733
static int opt_rec_timestamp(const char *opt, const char *arg)
2734
{
2735
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2736
    return 0;
2737
}
2738

    
2739
static int opt_input_ts_offset(const char *opt, const char *arg)
2740
{
2741
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2742
    return 0;
2743
}
2744

    
2745
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2746
{
2747
    const char *codec_string = encoder ? "encoder" : "decoder";
2748
    AVCodec *codec;
2749

    
2750
    if(!name)
2751
        return CODEC_ID_NONE;
2752
    codec = encoder ?
2753
        avcodec_find_encoder_by_name(name) :
2754
        avcodec_find_decoder_by_name(name);
2755
    if(!codec) {
2756
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2757
        av_exit(1);
2758
    }
2759
    if(codec->type != type) {
2760
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2761
        av_exit(1);
2762
    }
2763
    return codec->id;
2764
}
2765

    
2766
static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2767
{
2768
    int i;
2769
    for(i=0; i<opt_name_count; i++){
2770
        char buf[256];
2771
        const AVOption *opt;
2772
        const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2773
        /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2774
        if(str && ((opt->flags & flags) == flags))
2775
            av_set_string2(ctx, opt_names[i], str, 1);
2776
    }
2777
}
2778

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

    
2786
    if (!strcmp(filename, "-"))
2787
        filename = "pipe:";
2788

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

    
2792
    /* get default parameters from command line */
2793
    ic = av_alloc_format_context();
2794

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

    
2812
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2813

    
2814
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2815
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2816
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2817

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

    
2831
    ic->loop_input = loop_input;
2832

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

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

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

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

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

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

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

    
2901
            enc->rate_emu = rate_emu;
2902
            if(video_disable)
2903
                ic->streams[i]->discard= AVDISCARD_ALL;
2904
            else if(video_discard)
2905
                ic->streams[i]->discard= video_discard;
2906
            break;
2907
        case CODEC_TYPE_DATA:
2908
            break;
2909
        case CODEC_TYPE_SUBTITLE:
2910
            if(subtitle_disable)
2911
                ic->streams[i]->discard = AVDISCARD_ALL;
2912
            break;
2913
        case CODEC_TYPE_ATTACHMENT:
2914
        case CODEC_TYPE_UNKNOWN:
2915
            break;
2916
        default:
2917
            abort();
2918
        }
2919
    }
2920

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

    
2927
    nb_input_files++;
2928
    file_iformat = NULL;
2929
    file_oformat = NULL;
2930

    
2931
    video_channel = 0;
2932

    
2933
    rate_emu = 0;
2934
    av_freep(&video_codec_name);
2935
    av_freep(&audio_codec_name);
2936
    av_freep(&subtitle_codec_name);
2937
}
2938

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

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

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

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

    
2991
    if(thread_count>1)
2992
        avcodec_thread_init(st->codec, thread_count);
2993

    
2994
    video_enc = st->codec;
2995

    
2996
    if(video_codec_tag)
2997
        video_enc->codec_tag= video_codec_tag;
2998

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

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

    
3019
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3020
        if (video_codec_name)
3021
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3022

    
3023
        video_enc->codec_id = codec_id;
3024
        codec = avcodec_find_encoder(codec_id);
3025

    
3026
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3027

    
3028
        video_enc->time_base.den = fps.num;
3029
        video_enc->time_base.num = fps.den;
3030
        if(codec && codec->supported_framerates){
3031
            const AVRational *p= codec->supported_framerates;
3032
            const AVRational *best=NULL;
3033
            AVRational best_error= (AVRational){INT_MAX, 1};
3034
            for(; p->den!=0; p++){
3035
                AVRational error= av_sub_q(fps, *p);
3036
                if(error.num <0) error.num *= -1;
3037
                if(av_cmp_q(error, best_error) < 0){
3038
                    best_error= error;
3039
                    best= p;
3040
                }
3041
            }
3042
            video_enc->time_base.den= best->num;
3043
            video_enc->time_base.num= best->den;
3044
        }
3045

    
3046
        video_enc->width = frame_width + frame_padright + frame_padleft;
3047
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3048
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3049
        video_enc->pix_fmt = frame_pix_fmt;
3050
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3051

    
3052
        if(codec && codec->pix_fmts){
3053
            const enum PixelFormat *p= codec->pix_fmts;
3054
            for(; *p!=-1; p++){
3055
                if(*p == video_enc->pix_fmt)
3056
                    break;
3057
            }
3058
            if(*p == -1)
3059
                video_enc->pix_fmt = codec->pix_fmts[0];
3060
        }
3061

    
3062
        if (intra_only)
3063
            video_enc->gop_size = 0;
3064
        if (video_qscale || same_quality) {
3065
            video_enc->flags |= CODEC_FLAG_QSCALE;
3066
            video_enc->global_quality=
3067
                st->quality = FF_QP2LAMBDA * video_qscale;
3068
        }
3069

    
3070
        if(intra_matrix)
3071
            video_enc->intra_matrix = intra_matrix;
3072
        if(inter_matrix)
3073
            video_enc->inter_matrix = inter_matrix;
3074

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

    
3106
        if (do_psnr)
3107
            video_enc->flags|= CODEC_FLAG_PSNR;
3108

    
3109
        /* two pass mode */
3110
        if (do_pass) {
3111
            if (do_pass == 1) {
3112
                video_enc->flags |= CODEC_FLAG_PASS1;
3113
            } else {
3114
                video_enc->flags |= CODEC_FLAG_PASS2;
3115
            }
3116
        }
3117
    }
3118

    
3119
    /* reset some key parameters */
3120
    video_disable = 0;
3121
    av_freep(&video_codec_name);
3122
    video_stream_copy = 0;
3123
}
3124

    
3125
static void new_audio_stream(AVFormatContext *oc)
3126
{
3127
    AVStream *st;
3128
    AVCodecContext *audio_enc;
3129
    int codec_id;
3130

    
3131
    st = av_new_stream(oc, oc->nb_streams);
3132
    if (!st) {
3133
        fprintf(stderr, "Could not alloc stream\n");
3134
        av_exit(1);
3135
    }
3136
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3137

    
3138
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3139
    audio_bitstream_filters= NULL;
3140

    
3141
    if(thread_count>1)
3142
        avcodec_thread_init(st->codec, thread_count);
3143

    
3144
    audio_enc = st->codec;
3145
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3146

    
3147
    if(audio_codec_tag)
3148
        audio_enc->codec_tag= audio_codec_tag;
3149

    
3150
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3151
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3152
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3153
    }
3154
    if (audio_stream_copy) {
3155
        st->stream_copy = 1;
3156
        audio_enc->channels = audio_channels;
3157
    } else {
3158
        AVCodec *codec;
3159
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3160

    
3161
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3162

    
3163
        if (audio_codec_name)
3164
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3165
        audio_enc->codec_id = codec_id;
3166
        codec = avcodec_find_encoder(codec_id);
3167

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

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

    
3194
    /* reset some key parameters */
3195
    audio_disable = 0;
3196
    av_freep(&audio_codec_name);
3197
    audio_stream_copy = 0;
3198
}
3199

    
3200
static void new_subtitle_stream(AVFormatContext *oc)
3201
{
3202
    AVStream *st;
3203
    AVCodecContext *subtitle_enc;
3204

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

    
3212
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3213
    subtitle_bitstream_filters= NULL;
3214

    
3215
    subtitle_enc = st->codec;
3216
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3217
    if (subtitle_stream_copy) {
3218
        st->stream_copy = 1;
3219
    } else {
3220
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3221
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3222
    }
3223

    
3224
    if (subtitle_language) {
3225
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3226
        av_free(subtitle_language);
3227
        subtitle_language = NULL;
3228
    }
3229

    
3230
    subtitle_disable = 0;
3231
    av_freep(&subtitle_codec_name);
3232
    subtitle_stream_copy = 0;
3233
}
3234

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

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

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

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

    
3275
    if (!strcmp(filename, "-"))
3276
        filename = "pipe:";
3277

    
3278
    oc = av_alloc_format_context();
3279

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

    
3289
    oc->oformat = file_oformat;
3290
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3291

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

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

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

    
3330
        if (use_video) {
3331
            new_video_stream(oc);
3332
        }
3333

    
3334
        if (use_audio) {
3335
            new_audio_stream(oc);
3336
        }
3337

    
3338
        if (use_subtitle) {
3339
            new_subtitle_stream(oc);
3340
        }
3341

    
3342
        oc->timestamp = rec_timestamp;
3343

    
3344
        if (str_title)
3345
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3346
        if (str_author)
3347
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3348
        if (str_copyright)
3349
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3350
        if (str_comment)
3351
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3352
        if (str_album)
3353
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3354
        if (str_genre)
3355
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3356
    }
3357

    
3358
    output_files[nb_output_files++] = oc;
3359

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

    
3368
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3369
        /* test if it already exists to avoid loosing precious files */
3370
        if (!file_overwrite &&
3371
            (strchr(filename, ':') == NULL ||
3372
             filename[1] == ':' ||
3373
             av_strstart(filename, "file:", NULL))) {
3374
            if (url_exist(filename)) {
3375
                int c;
3376

    
3377
                if (!using_stdin) {
3378
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3379
                    fflush(stderr);
3380
                    c = getchar();
3381
                    if (toupper(c) != 'Y') {
3382
                        fprintf(stderr, "Not overwriting - exiting\n");
3383
                        av_exit(1);
3384
                    }
3385
                }
3386
                else {
3387
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3388
                    av_exit(1);
3389
                }
3390
            }
3391
        }
3392

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

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

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

    
3411
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3412

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3623

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

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

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

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

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

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

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

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

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

    
3652
        opt_format("dv");
3653

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

    
3659
        audio_sample_rate = 48000;
3660
        audio_channels = 2;
3661

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

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

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

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

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

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

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

    
3701
    *bsfp= bsfc;
3702

    
3703
    return 0;
3704
}
3705

    
3706
static int opt_preset(const char *opt, const char *arg)
3707
{
3708
    FILE *f=NULL;
3709
    char tmp[1000], tmp2[1000];
3710
    int i;
3711
    const char *base[3]= { getenv("HOME"),
3712
                           "/usr/local/share",
3713
                           "/usr/share",
3714
                         };
3715

    
3716
    for(i=!base[0]; i<3 && !f; i++){
3717
        snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3718
        f= fopen(tmp, "r");
3719
        if(!f){
3720
            char *codec_name= *opt == 'v' ? video_codec_name :
3721
                              *opt == 'a' ? audio_codec_name :
3722
                                            subtitle_codec_name;
3723
              snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3724
            f= fopen(tmp, "r");
3725
        }
3726
    }
3727

    
3728
    if(!f){
3729
        fprintf(stderr, "Preset file not found\n");
3730
        av_exit(1);
3731
    }
3732

    
3733
    while(!feof(f)){
3734
        int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3735
        if(e!=2){
3736
            fprintf(stderr, "Preset file invalid\n");
3737
            av_exit(1);
3738
        }
3739
        if(!strcmp(tmp, "acodec")){
3740
            opt_audio_codec(tmp2);
3741
        }else if(!strcmp(tmp, "vcodec")){
3742
            opt_video_codec(tmp2);
3743
        }else if(!strcmp(tmp, "scodec")){
3744
            opt_subtitle_codec(tmp2);
3745
        }else
3746
            opt_default(tmp, tmp2);
3747
    }
3748

    
3749
    fclose(f);
3750

    
3751
    return 0;
3752
}
3753

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

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

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

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

    
3863
    /* grab options */
3864
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3865
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3866
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3867

    
3868
    /* muxer options */
3869
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3870
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3871

    
3872
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3873
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3874
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3875

    
3876
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3877
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3878
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3879

    
3880
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3881
    { NULL, },
3882
};
3883

    
3884
int main(int argc, char **argv)
3885
{
3886
    int i;
3887
    int64_t ti;
3888

    
3889
    avcodec_register_all();
3890
    avdevice_register_all();
3891
    av_register_all();
3892

    
3893
    if(isatty(STDIN_FILENO))
3894
        url_set_interrupt_cb(decode_interrupt_cb);
3895

    
3896
    for(i=0; i<CODEC_TYPE_NB; i++){
3897
        avctx_opts[i]= avcodec_alloc_context2(i);
3898
    }
3899
    avformat_opts = av_alloc_format_context();
3900
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3901

    
3902
    show_banner();
3903
    if (argc <= 1) {
3904
        show_help();
3905
        av_exit(1);
3906
    }
3907

    
3908
    /* parse options */
3909
    parse_options(argc, argv, options, opt_output_file);
3910

    
3911
    /* file converter / grab */
3912
    if (nb_output_files <= 0) {
3913
        fprintf(stderr, "Must supply at least one output file\n");
3914
        av_exit(1);
3915
    }
3916

    
3917
    if (nb_input_files == 0) {
3918
        fprintf(stderr, "Must supply at least one input file\n");
3919
        av_exit(1);
3920
    }
3921

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

    
3930
    return av_exit(0);
3931
}