Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 002c95d7

History | View | Annotate | Download (139 KB)

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

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

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

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

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

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

    
65
#include "cmdutils.h"
66

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

    
70
#undef exit
71

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

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

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

    
89
static const OptionDef options[];
90

    
91
#define MAX_FILES 20
92

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

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

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

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

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

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

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

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

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

    
196
static int rate_emu = 0;
197

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

    
201
static int audio_volume = 256;
202

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

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

    
220
static unsigned int sws_flags = SWS_BICUBIC;
221

    
222
static int64_t timer_start;
223

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

    
229
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
230

    
231
struct AVInputStream;
232

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

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

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

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

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

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

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

    
292
#if HAVE_TERMIOS_H
293

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

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

    
305
static volatile sig_atomic_t received_sigterm = 0;
306

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
416
    av_free(opt_names);
417

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

    
422
    av_free(video_standard);
423

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
511
        bsfc= bsfc->next;
512
    }
513

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

    
521
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
522

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
675
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
676

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
850
    *frame_size = 0;
851

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1072

    
1073
    oc = output_files[0];
1074

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

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

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

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

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

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

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

    
1154
        fflush(stderr);
1155
    }
1156

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1536
    return -1;
1537
}
1538

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

    
1560
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1561
    if (!file_table)
1562
        goto fail;
1563

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

    
1574
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1575
    if (!ist_table)
1576
        goto fail;
1577

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

    
1595
            if (rate_emu) {
1596
                ist->start = av_gettime();
1597
            }
1598
        }
1599
    }
1600

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

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

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

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

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

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

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

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

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

    
1726
        codec = ost->st->codec;
1727
        icodec = ist->st->codec;
1728

    
1729
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1730
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1731
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1732

    
1733
        ost->st->disposition = ist->st->disposition;
1734

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

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

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

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

    
1901
    if (!bit_buffer)
1902
        bit_buffer = av_malloc(bit_buffer_size);
1903
    if (!bit_buffer) {
1904
        ret = AVERROR(ENOMEM);
1905
        goto fail;
1906
    }
1907

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

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

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

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

    
1970
        int out_file_index = meta_data_maps[i].out_file;
1971
        int in_file_index = meta_data_maps[i].in_file;
1972
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1973
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
1974
                     out_file_index, out_file_index, in_file_index);
1975
            ret = AVERROR(EINVAL);
1976
            goto dump_format;
1977
        }
1978
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1979
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
1980
                     in_file_index, out_file_index, in_file_index);
1981
            ret = AVERROR(EINVAL);
1982
            goto dump_format;
1983
        }
1984

    
1985
        out_file = output_files[out_file_index];
1986
        in_file = input_files[in_file_index];
1987

    
1988

    
1989
        mtag=NULL;
1990
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
1991
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
1992
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
1993
                                    in_file->iformat->metadata_conv);
1994
    }
1995

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

    
2009
 dump_format:
2010
    /* dump the file output parameters - cannot be done before in case
2011
       of stream copy */
2012
    for(i=0;i<nb_output_files;i++) {
2013
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2014
    }
2015

    
2016
    /* dump the stream mapping */
2017
    if (verbose >= 0) {
2018
        fprintf(stderr, "Stream mapping:\n");
2019
        for(i=0;i<nb_ostreams;i++) {
2020
            ost = ost_table[i];
2021
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2022
                    ist_table[ost->source_index]->file_index,
2023
                    ist_table[ost->source_index]->index,
2024
                    ost->file_index,
2025
                    ost->index);
2026
            if (ost->sync_ist != ist_table[ost->source_index])
2027
                fprintf(stderr, " [sync #%d.%d]",
2028
                        ost->sync_ist->file_index,
2029
                        ost->sync_ist->index);
2030
            fprintf(stderr, "\n");
2031
        }
2032
    }
2033

    
2034
    if (ret) {
2035
        fprintf(stderr, "%s\n", error);
2036
        goto fail;
2037
    }
2038

    
2039
    if (want_sdp) {
2040
        print_sdp(output_files, nb_output_files);
2041
    }
2042

    
2043
    if (!using_stdin && verbose >= 0) {
2044
        fprintf(stderr, "Press [q] to stop encoding\n");
2045
        url_set_interrupt_cb(decode_interrupt_cb);
2046
    }
2047
    term_init();
2048

    
2049
    key = -1;
2050
    timer_start = av_gettime();
2051

    
2052
    for(; received_sigterm == 0;) {
2053
        int file_index, ist_index;
2054
        AVPacket pkt;
2055
        double ipts_min;
2056
        double opts_min;
2057

    
2058
    redo:
2059
        ipts_min= 1e100;
2060
        opts_min= 1e100;
2061
        /* if 'q' pressed, exits */
2062
        if (!using_stdin) {
2063
            if (q_pressed)
2064
                break;
2065
            /* read_key() returns 0 on EOF */
2066
            key = read_key();
2067
            if (key == 'q')
2068
                break;
2069
        }
2070

    
2071
        /* select the stream that we must read now by looking at the
2072
           smallest output pts */
2073
        file_index = -1;
2074
        for(i=0;i<nb_ostreams;i++) {
2075
            double ipts, opts;
2076
            ost = ost_table[i];
2077
            os = output_files[ost->file_index];
2078
            ist = ist_table[ost->source_index];
2079
            if(no_packet[ist->file_index])
2080
                continue;
2081
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2082
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2083
            else
2084
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2085
            ipts = (double)ist->pts;
2086
            if (!file_table[ist->file_index].eof_reached){
2087
                if(ipts < ipts_min) {
2088
                    ipts_min = ipts;
2089
                    if(input_sync ) file_index = ist->file_index;
2090
                }
2091
                if(opts < opts_min) {
2092
                    opts_min = opts;
2093
                    if(!input_sync) file_index = ist->file_index;
2094
                }
2095
            }
2096
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2097
                file_index= -1;
2098
                break;
2099
            }
2100
        }
2101
        /* if none, if is finished */
2102
        if (file_index < 0) {
2103
            if(no_packet_count){
2104
                no_packet_count=0;
2105
                memset(no_packet, 0, sizeof(no_packet));
2106
                usleep(10000);
2107
                continue;
2108
            }
2109
            break;
2110
        }
2111

    
2112
        /* finish if recording time exhausted */
2113
        if (opts_min >= (recording_time / 1000000.0))
2114
            break;
2115

    
2116
        /* finish if limit size exhausted */
2117
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2118
            break;
2119

    
2120
        /* read a frame from it and output it in the fifo */
2121
        is = input_files[file_index];
2122
        ret= av_read_frame(is, &pkt);
2123
        if(ret == AVERROR(EAGAIN) && strcmp(is->iformat->name, "ffm")){
2124
            no_packet[file_index]=1;
2125
            no_packet_count++;
2126
            continue;
2127
        }
2128
        if (ret < 0) {
2129
            file_table[file_index].eof_reached = 1;
2130
            if (opt_shortest)
2131
                break;
2132
            else
2133
                continue;
2134
        }
2135

    
2136
        no_packet_count=0;
2137
        memset(no_packet, 0, sizeof(no_packet));
2138

    
2139
        if (do_pkt_dump) {
2140
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2141
        }
2142
        /* the following test is needed in case new streams appear
2143
           dynamically in stream : we ignore them */
2144
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2145
            goto discard_packet;
2146
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2147
        ist = ist_table[ist_index];
2148
        if (ist->discard)
2149
            goto discard_packet;
2150

    
2151
        if (pkt.dts != AV_NOPTS_VALUE)
2152
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2153
        if (pkt.pts != AV_NOPTS_VALUE)
2154
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2155

    
2156
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2157
            if(pkt.pts != AV_NOPTS_VALUE)
2158
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2159
            if(pkt.dts != AV_NOPTS_VALUE)
2160
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2161
        }
2162

    
2163
//        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);
2164
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2165
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2166
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2167
            int64_t delta= pkt_dts - ist->next_pts;
2168
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2169
                input_files_ts_offset[ist->file_index]-= delta;
2170
                if (verbose > 2)
2171
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2172
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2173
                if(pkt.pts != AV_NOPTS_VALUE)
2174
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2175
            }
2176
        }
2177

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

    
2181
            if (verbose >= 0)
2182
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2183
                        ist->file_index, ist->index);
2184
            if (exit_on_error)
2185
                av_exit(1);
2186
            av_free_packet(&pkt);
2187
            goto redo;
2188
        }
2189

    
2190
    discard_packet:
2191
        av_free_packet(&pkt);
2192

    
2193
        /* dump report by using the output first video and audio streams */
2194
        print_report(output_files, ost_table, nb_ostreams, 0);
2195
    }
2196

    
2197
    /* at the end of stream, we must flush the decoder buffers */
2198
    for(i=0;i<nb_istreams;i++) {
2199
        ist = ist_table[i];
2200
        if (ist->decoding_needed) {
2201
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2202
        }
2203
    }
2204

    
2205
    term_exit();
2206

    
2207
    /* write the trailer if needed and close file */
2208
    for(i=0;i<nb_output_files;i++) {
2209
        os = output_files[i];
2210
        av_write_trailer(os);
2211
    }
2212

    
2213
    /* dump report by using the first video and audio streams */
2214
    print_report(output_files, ost_table, nb_ostreams, 1);
2215

    
2216
    /* close each encoder */
2217
    for(i=0;i<nb_ostreams;i++) {
2218
        ost = ost_table[i];
2219
        if (ost->encoding_needed) {
2220
            av_freep(&ost->st->codec->stats_in);
2221
            avcodec_close(ost->st->codec);
2222
        }
2223
    }
2224

    
2225
    /* close each decoder */
2226
    for(i=0;i<nb_istreams;i++) {
2227
        ist = ist_table[i];
2228
        if (ist->decoding_needed) {
2229
            avcodec_close(ist->st->codec);
2230
        }
2231
    }
2232

    
2233
    /* finished ! */
2234

    
2235
 fail:
2236
    av_freep(&bit_buffer);
2237
    av_free(file_table);
2238

    
2239
    if (ist_table) {
2240
        for(i=0;i<nb_istreams;i++) {
2241
            ist = ist_table[i];
2242
            av_free(ist);
2243
        }
2244
        av_free(ist_table);
2245
    }
2246
    if (ost_table) {
2247
        for(i=0;i<nb_ostreams;i++) {
2248
            ost = ost_table[i];
2249
            if (ost) {
2250
                if (ost->logfile) {
2251
                    fclose(ost->logfile);
2252
                    ost->logfile = NULL;
2253
                }
2254
                av_fifo_free(ost->fifo); /* works even if fifo is not
2255
                                             initialized but set to zero */
2256
                av_free(ost->pict_tmp.data[0]);
2257
                if (ost->video_resample)
2258
                    sws_freeContext(ost->img_resample_ctx);
2259
                if (ost->resample)
2260
                    audio_resample_close(ost->resample);
2261
                if (ost->reformat_ctx)
2262
                    av_audio_convert_free(ost->reformat_ctx);
2263
                av_free(ost);
2264
            }
2265
        }
2266
        av_free(ost_table);
2267
    }
2268
    return ret;
2269
}
2270

    
2271
#if 0
2272
int file_read(const char *filename)
2273
{
2274
    URLContext *h;
2275
    unsigned char buffer[1024];
2276
    int len, i;
2277

2278
    if (url_open(&h, filename, O_RDONLY) < 0) {
2279
        printf("could not open '%s'\n", filename);
2280
        return -1;
2281
    }
2282
    for(;;) {
2283
        len = url_read(h, buffer, sizeof(buffer));
2284
        if (len <= 0)
2285
            break;
2286
        for(i=0;i<len;i++) putchar(buffer[i]);
2287
    }
2288
    url_close(h);
2289
    return 0;
2290
}
2291
#endif
2292

    
2293
static void opt_format(const char *arg)
2294
{
2295
    /* compatibility stuff for pgmyuv */
2296
    if (!strcmp(arg, "pgmyuv")) {
2297
        pgmyuv_compatibility_hack=1;
2298
//        opt_image_format(arg);
2299
        arg = "image2";
2300
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2301
    }
2302

    
2303
    file_iformat = av_find_input_format(arg);
2304
    file_oformat = guess_format(arg, NULL, NULL);
2305
    if (!file_iformat && !file_oformat) {
2306
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2307
        av_exit(1);
2308
    }
2309
}
2310

    
2311
static void opt_video_rc_override_string(const char *arg)
2312
{
2313
    video_rc_override_string = arg;
2314
}
2315

    
2316
static int opt_me_threshold(const char *opt, const char *arg)
2317
{
2318
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2319
    return 0;
2320
}
2321

    
2322
static int opt_verbose(const char *opt, const char *arg)
2323
{
2324
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2325
    av_log_set_level(verbose);
2326
    return 0;
2327
}
2328

    
2329
static int opt_frame_rate(const char *opt, const char *arg)
2330
{
2331
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2332
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2333
        av_exit(1);
2334
    }
2335
    return 0;
2336
}
2337

    
2338
static int opt_bitrate(const char *opt, const char *arg)
2339
{
2340
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2341

    
2342
    opt_default(opt, arg);
2343

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

    
2347
    return 0;
2348
}
2349

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

    
2368
static void opt_frame_crop_bottom(const char *arg)
2369
{
2370
    frame_bottomBand = atoi(arg);
2371
    if (frame_bottomBand < 0) {
2372
        fprintf(stderr, "Incorrect bottom crop size\n");
2373
        av_exit(1);
2374
    }
2375
    if ((frame_bottomBand % 2) != 0) {
2376
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2377
        av_exit(1);
2378
    }
2379
    if ((frame_bottomBand) >= frame_height){
2380
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2381
        av_exit(1);
2382
    }
2383
    frame_height -= frame_bottomBand;
2384
}
2385

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

    
2404
static void opt_frame_crop_right(const char *arg)
2405
{
2406
    frame_rightBand = atoi(arg);
2407
    if (frame_rightBand < 0) {
2408
        fprintf(stderr, "Incorrect right crop size\n");
2409
        av_exit(1);
2410
    }
2411
    if ((frame_rightBand % 2) != 0) {
2412
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2413
        av_exit(1);
2414
    }
2415
    if ((frame_rightBand) >= frame_width){
2416
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2417
        av_exit(1);
2418
    }
2419
    frame_width -= frame_rightBand;
2420
}
2421

    
2422
static void opt_frame_size(const char *arg)
2423
{
2424
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2425
        fprintf(stderr, "Incorrect frame size\n");
2426
        av_exit(1);
2427
    }
2428
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2429
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2430
        av_exit(1);
2431
    }
2432
}
2433

    
2434

    
2435
#define SCALEBITS 10
2436
#define ONE_HALF  (1 << (SCALEBITS - 1))
2437
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2438

    
2439
#define RGB_TO_Y(r, g, b) \
2440
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2441
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2442

    
2443
#define RGB_TO_U(r1, g1, b1, shift)\
2444
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2445
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2446

    
2447
#define RGB_TO_V(r1, g1, b1, shift)\
2448
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2449
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2450

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

    
2457
    r = (rgb >> 16);
2458
    g = ((rgb >> 8) & 255);
2459
    b = (rgb & 255);
2460

    
2461
    padcolor[0] = RGB_TO_Y(r,g,b);
2462
    padcolor[1] = RGB_TO_U(r,g,b,0);
2463
    padcolor[2] = RGB_TO_V(r,g,b,0);
2464
}
2465

    
2466
static void opt_frame_pad_top(const char *arg)
2467
{
2468
    frame_padtop = atoi(arg);
2469
    if (frame_padtop < 0) {
2470
        fprintf(stderr, "Incorrect top pad size\n");
2471
        av_exit(1);
2472
    }
2473
    if ((frame_padtop % 2) != 0) {
2474
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2475
        av_exit(1);
2476
    }
2477
}
2478

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

    
2492

    
2493
static void opt_frame_pad_left(const char *arg)
2494
{
2495
    frame_padleft = atoi(arg);
2496
    if (frame_padleft < 0) {
2497
        fprintf(stderr, "Incorrect left pad size\n");
2498
        av_exit(1);
2499
    }
2500
    if ((frame_padleft % 2) != 0) {
2501
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2502
        av_exit(1);
2503
    }
2504
}
2505

    
2506

    
2507
static void opt_frame_pad_right(const char *arg)
2508
{
2509
    frame_padright = atoi(arg);
2510
    if (frame_padright < 0) {
2511
        fprintf(stderr, "Incorrect right pad size\n");
2512
        av_exit(1);
2513
    }
2514
    if ((frame_padright % 2) != 0) {
2515
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2516
        av_exit(1);
2517
    }
2518
}
2519

    
2520
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2521
{
2522
    int i;
2523
    char fmt_str[128];
2524
    for (i=-1; i < nb_fmts; i++) {
2525
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2526
        fprintf(stdout, "%s\n", fmt_str);
2527
    }
2528
}
2529

    
2530
static void opt_frame_pix_fmt(const char *arg)
2531
{
2532
    if (strcmp(arg, "list"))
2533
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2534
    else {
2535
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2536
        av_exit(0);
2537
    }
2538
}
2539

    
2540
static void opt_frame_aspect_ratio(const char *arg)
2541
{
2542
    int x = 0, y = 0;
2543
    double ar = 0;
2544
    const char *p;
2545
    char *end;
2546

    
2547
    p = strchr(arg, ':');
2548
    if (p) {
2549
        x = strtol(arg, &end, 10);
2550
        if (end == p)
2551
            y = strtol(end+1, &end, 10);
2552
        if (x > 0 && y > 0)
2553
            ar = (double)x / (double)y;
2554
    } else
2555
        ar = strtod(arg, NULL);
2556

    
2557
    if (!ar) {
2558
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2559
        av_exit(1);
2560
    }
2561
    frame_aspect_ratio = ar;
2562
}
2563

    
2564
static int opt_metadata(const char *opt, const char *arg)
2565
{
2566
    char *mid= strchr(arg, '=');
2567

    
2568
    if(!mid){
2569
        fprintf(stderr, "Missing =\n");
2570
        av_exit(1);
2571
    }
2572
    *mid++= 0;
2573

    
2574
    metadata_count++;
2575
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2576
    metadata[metadata_count-1].key  = av_strdup(arg);
2577
    metadata[metadata_count-1].value= av_strdup(mid);
2578

    
2579
    return 0;
2580
}
2581

    
2582
static void opt_qscale(const char *arg)
2583
{
2584
    video_qscale = atof(arg);
2585
    if (video_qscale <= 0 ||
2586
        video_qscale > 255) {
2587
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2588
        av_exit(1);
2589
    }
2590
}
2591

    
2592
static void opt_top_field_first(const char *arg)
2593
{
2594
    top_field_first= atoi(arg);
2595
}
2596

    
2597
static int opt_thread_count(const char *opt, const char *arg)
2598
{
2599
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2600
#if !HAVE_THREADS
2601
    if (verbose >= 0)
2602
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2603
#endif
2604
    return 0;
2605
}
2606

    
2607
static void opt_audio_sample_fmt(const char *arg)
2608
{
2609
    if (strcmp(arg, "list"))
2610
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2611
    else {
2612
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2613
        av_exit(0);
2614
    }
2615
}
2616

    
2617
static int opt_audio_rate(const char *opt, const char *arg)
2618
{
2619
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2620
    return 0;
2621
}
2622

    
2623
static int opt_audio_channels(const char *opt, const char *arg)
2624
{
2625
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2626
    return 0;
2627
}
2628

    
2629
static void opt_video_channel(const char *arg)
2630
{
2631
    video_channel = strtol(arg, NULL, 0);
2632
}
2633

    
2634
static void opt_video_standard(const char *arg)
2635
{
2636
    video_standard = av_strdup(arg);
2637
}
2638

    
2639
static void opt_codec(int *pstream_copy, char **pcodec_name,
2640
                      int codec_type, const char *arg)
2641
{
2642
    av_freep(pcodec_name);
2643
    if (!strcmp(arg, "copy")) {
2644
        *pstream_copy = 1;
2645
    } else {
2646
        *pcodec_name = av_strdup(arg);
2647
    }
2648
}
2649

    
2650
static void opt_audio_codec(const char *arg)
2651
{
2652
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2653
}
2654

    
2655
static void opt_audio_tag(const char *arg)
2656
{
2657
    char *tail;
2658
    audio_codec_tag= strtol(arg, &tail, 0);
2659

    
2660
    if(!tail || *tail)
2661
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2662
}
2663

    
2664
static void opt_video_tag(const char *arg)
2665
{
2666
    char *tail;
2667
    video_codec_tag= strtol(arg, &tail, 0);
2668

    
2669
    if(!tail || *tail)
2670
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2671
}
2672

    
2673
static void opt_video_codec(const char *arg)
2674
{
2675
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2676
}
2677

    
2678
static void opt_subtitle_codec(const char *arg)
2679
{
2680
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2681
}
2682

    
2683
static void opt_map(const char *arg)
2684
{
2685
    AVStreamMap *m;
2686
    char *p;
2687

    
2688
    m = &stream_maps[nb_stream_maps++];
2689

    
2690
    m->file_index = strtol(arg, &p, 0);
2691
    if (*p)
2692
        p++;
2693

    
2694
    m->stream_index = strtol(p, &p, 0);
2695
    if (*p) {
2696
        p++;
2697
        m->sync_file_index = strtol(p, &p, 0);
2698
        if (*p)
2699
            p++;
2700
        m->sync_stream_index = strtol(p, &p, 0);
2701
    } else {
2702
        m->sync_file_index = m->file_index;
2703
        m->sync_stream_index = m->stream_index;
2704
    }
2705
}
2706

    
2707
static void opt_map_meta_data(const char *arg)
2708
{
2709
    AVMetaDataMap *m;
2710
    char *p;
2711

    
2712
    m = &meta_data_maps[nb_meta_data_maps++];
2713

    
2714
    m->out_file = strtol(arg, &p, 0);
2715
    if (*p)
2716
        p++;
2717

    
2718
    m->in_file = strtol(p, &p, 0);
2719
}
2720

    
2721
static void opt_input_ts_scale(const char *arg)
2722
{
2723
    unsigned int stream;
2724
    double scale;
2725
    char *p;
2726

    
2727
    stream = strtol(arg, &p, 0);
2728
    if (*p)
2729
        p++;
2730
    scale= strtod(p, &p);
2731

    
2732
    if(stream >= MAX_STREAMS)
2733
        av_exit(1);
2734

    
2735
    input_files_ts_scale[nb_input_files][stream]= scale;
2736
}
2737

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

    
2744
static int opt_start_time(const char *opt, const char *arg)
2745
{
2746
    start_time = parse_time_or_die(opt, arg, 1);
2747
    return 0;
2748
}
2749

    
2750
static int opt_rec_timestamp(const char *opt, const char *arg)
2751
{
2752
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2753
    return 0;
2754
}
2755

    
2756
static int opt_input_ts_offset(const char *opt, const char *arg)
2757
{
2758
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2759
    return 0;
2760
}
2761

    
2762
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2763
{
2764
    const char *codec_string = encoder ? "encoder" : "decoder";
2765
    AVCodec *codec;
2766

    
2767
    if(!name)
2768
        return CODEC_ID_NONE;
2769
    codec = encoder ?
2770
        avcodec_find_encoder_by_name(name) :
2771
        avcodec_find_decoder_by_name(name);
2772
    if(!codec) {
2773
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2774
        av_exit(1);
2775
    }
2776
    if(codec->type != type) {
2777
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2778
        av_exit(1);
2779
    }
2780
    return codec->id;
2781
}
2782

    
2783
static void opt_input_file(const char *filename)
2784
{
2785
    AVFormatContext *ic;
2786
    AVFormatParameters params, *ap = &params;
2787
    int err, i, ret, rfps, rfps_base;
2788
    int64_t timestamp;
2789

    
2790
    if (!strcmp(filename, "-"))
2791
        filename = "pipe:";
2792

    
2793
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2794
                    !strcmp(filename, "/dev/stdin");
2795

    
2796
    /* get default parameters from command line */
2797
    ic = avformat_alloc_context();
2798

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

    
2816
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2817

    
2818
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2819
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2820
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2821
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2822

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

    
2836
    ic->loop_input = loop_input;
2837

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

    
2846
    timestamp = start_time;
2847
    /* add the stream start time */
2848
    if (ic->start_time != AV_NOPTS_VALUE)
2849
        timestamp += ic->start_time;
2850

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

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

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

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

    
2902
                    (float)rfps / rfps_base, rfps, rfps_base);
2903
            }
2904
            /* update the current frame rate to match the stream frame rate */
2905
            frame_rate.num = rfps;
2906
            frame_rate.den = rfps_base;
2907

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

    
2930
    input_files[nb_input_files] = ic;
2931
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2932
    /* dump the file content */
2933
    if (verbose >= 0)
2934
        dump_format(ic, nb_input_files, filename, 0);
2935

    
2936
    nb_input_files++;
2937
    file_iformat = NULL;
2938
    file_oformat = NULL;
2939

    
2940
    video_channel = 0;
2941

    
2942
    av_freep(&video_codec_name);
2943
    av_freep(&audio_codec_name);
2944
    av_freep(&subtitle_codec_name);
2945
}
2946

    
2947
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2948
                                         int *has_subtitle_ptr)
2949
{
2950
    int has_video, has_audio, has_subtitle, i, j;
2951
    AVFormatContext *ic;
2952

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

    
2984
static void new_video_stream(AVFormatContext *oc)
2985
{
2986
    AVStream *st;
2987
    AVCodecContext *video_enc;
2988
    int codec_id;
2989

    
2990
    st = av_new_stream(oc, oc->nb_streams);
2991
    if (!st) {
2992
        fprintf(stderr, "Could not alloc stream\n");
2993
        av_exit(1);
2994
    }
2995
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2996
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2997
    video_bitstream_filters= NULL;
2998

    
2999
    if(thread_count>1)
3000
        avcodec_thread_init(st->codec, thread_count);
3001

    
3002
    video_enc = st->codec;
3003

    
3004
    if(video_codec_tag)
3005
        video_enc->codec_tag= video_codec_tag;
3006

    
3007
    if(   (video_global_header&1)
3008
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3009
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3010
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3011
    }
3012
    if(video_global_header&2){
3013
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3014
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3015
    }
3016

    
3017
    if (video_stream_copy) {
3018
        st->stream_copy = 1;
3019
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3020
        video_enc->sample_aspect_ratio =
3021
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3022
    } else {
3023
        const char *p;
3024
        int i;
3025
        AVCodec *codec;
3026
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3027

    
3028
        if (video_codec_name) {
3029
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3030
            codec = avcodec_find_encoder_by_name(video_codec_name);
3031
            output_codecs[nb_ocodecs] = codec;
3032
        } else {
3033
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3034
            codec = avcodec_find_encoder(codec_id);
3035
        }
3036

    
3037
        video_enc->codec_id = codec_id;
3038

    
3039
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3040

    
3041
        if (codec && codec->supported_framerates && !force_fps)
3042
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3043
        video_enc->time_base.den = fps.num;
3044
        video_enc->time_base.num = fps.den;
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
    nb_ocodecs++;
3119

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

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

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

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

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

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

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

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

    
3161
        set_context_opts(audio_enc, avcodec_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
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3166
            output_codecs[nb_ocodecs] = codec;
3167
        } else {
3168
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3169
            codec = avcodec_find_encoder(codec_id);
3170
        }
3171
        audio_enc->codec_id = codec_id;
3172

    
3173
        if (audio_qscale > QSCALE_NONE) {
3174
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3175
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3176
        }
3177
        audio_enc->thread_count = thread_count;
3178
        audio_enc->channels = audio_channels;
3179
        audio_enc->sample_fmt = audio_sample_fmt;
3180
        audio_enc->channel_layout = channel_layout;
3181

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

    
3201
    /* reset some key parameters */
3202
    audio_disable = 0;
3203
    av_freep(&audio_codec_name);
3204
    audio_stream_copy = 0;
3205
}
3206

    
3207
static void new_subtitle_stream(AVFormatContext *oc)
3208
{
3209
    AVStream *st;
3210
    AVCodecContext *subtitle_enc;
3211

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

    
3219
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3220
    subtitle_bitstream_filters= NULL;
3221

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

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

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

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

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

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

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

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

    
3287
    oc = avformat_alloc_context();
3288

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

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

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

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

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

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

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

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

    
3351
        oc->timestamp = rec_timestamp;
3352

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

    
3360
    output_files[nb_output_files++] = oc;
3361

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

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

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

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

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

    
3409
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3410
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3411
    oc->loop_output = loop_output;
3412
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3413

    
3414
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3415

    
3416
    /* reset some options */
3417
    file_oformat = NULL;
3418
    file_iformat = NULL;
3419
}
3420

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

    
3433
static int64_t getutime(void)
3434
{
3435
#if HAVE_GETRUSAGE
3436
    struct rusage rusage;
3437

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

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

    
3468
static void opt_inter_matrix(const char *arg)
3469
{
3470
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3471
    parse_matrix_coeffs(inter_matrix, arg);
3472
}
3473

    
3474
static void opt_intra_matrix(const char *arg)
3475
{
3476
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3477
    parse_matrix_coeffs(intra_matrix, arg);
3478
}
3479

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

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

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

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

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

    
3582
    if(!strcmp(arg, "vcd")) {
3583

    
3584
        opt_video_codec("mpeg1video");
3585
        opt_audio_codec("mp2");
3586
        opt_format("vcd");
3587

    
3588
        opt_frame_size(norm ? "352x240" : "352x288");
3589
        opt_frame_rate(NULL, frame_rates[norm]);
3590
        opt_default("gop", norm ? "18" : "15");
3591

    
3592
        opt_default("b", "1150000");
3593
        opt_default("maxrate", "1150000");
3594
        opt_default("minrate", "1150000");
3595
        opt_default("bufsize", "327680"); // 40*1024*8;
3596

    
3597
        opt_default("ab", "224000");
3598
        audio_sample_rate = 44100;
3599
        audio_channels = 2;
3600

    
3601
        opt_default("packetsize", "2324");
3602
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3603

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

    
3612
        opt_video_codec("mpeg2video");
3613
        opt_audio_codec("mp2");
3614
        opt_format("svcd");
3615

    
3616
        opt_frame_size(norm ? "480x480" : "480x576");
3617
        opt_frame_rate(NULL, frame_rates[norm]);
3618
        opt_default("gop", norm ? "18" : "15");
3619

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

    
3626

    
3627
        opt_default("ab", "224000");
3628
        audio_sample_rate = 44100;
3629

    
3630
        opt_default("packetsize", "2324");
3631

    
3632
    } else if(!strcmp(arg, "dvd")) {
3633

    
3634
        opt_video_codec("mpeg2video");
3635
        opt_audio_codec("ac3");
3636
        opt_format("dvd");
3637

    
3638
        opt_frame_size(norm ? "720x480" : "720x576");
3639
        opt_frame_rate(NULL, frame_rates[norm]);
3640
        opt_default("gop", norm ? "18" : "15");
3641

    
3642
        opt_default("b", "6000000");
3643
        opt_default("maxrate", "9000000");
3644
        opt_default("minrate", "0"); //1500000;
3645
        opt_default("bufsize", "1835008"); //224*1024*8;
3646

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

    
3650
        opt_default("ab", "448000");
3651
        audio_sample_rate = 48000;
3652

    
3653
    } else if(!strncmp(arg, "dv", 2)) {
3654

    
3655
        opt_format("dv");
3656

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

    
3662
        audio_sample_rate = 48000;
3663
        audio_channels = 2;
3664

    
3665
    } else {
3666
        fprintf(stderr, "Unknown target: %s\n", arg);
3667
        av_exit(1);
3668
    }
3669
}
3670

    
3671
static void opt_vstats_file (const char *arg)
3672
{
3673
    av_free (vstats_filename);
3674
    vstats_filename=av_strdup (arg);
3675
}
3676

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

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

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

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

    
3698
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3699
          *opt == 'a' ? &audio_bitstream_filters :
3700
                        &subtitle_bitstream_filters;
3701
    while(*bsfp)
3702
        bsfp= &(*bsfp)->next;
3703

    
3704
    *bsfp= bsfc;
3705

    
3706
    return 0;
3707
}
3708

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

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

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

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

    
3761
    fclose(f);
3762

    
3763
    return 0;
3764
}
3765

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3909
    show_banner();
3910

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

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

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

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

    
3934
    return av_exit(0);
3935
}