Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ d61f30a7

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_read(&ost->fifo, audio_buf, frame_bytes);
676

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
850
    *frame_size = 0;
851

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1072

    
1073
    oc = output_files[0];
1074

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

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

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

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

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

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

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

    
1154
        fflush(stderr);
1155
    }
1156

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1536
    return -1;
1537
}
1538

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1899
    if (!bit_buffer)
1900
        bit_buffer = av_malloc(bit_buffer_size);
1901
    if (!bit_buffer)
1902
        goto fail;
1903

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

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

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

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

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

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

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

    
1999
        out_file = output_files[out_file_index];
2000
        in_file = input_files[in_file_index];
2001

    
2002

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

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

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

    
2032
    key = -1;
2033
    timer_start = av_gettime();
2034

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

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

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

    
2095
        /* finish if recording time exhausted */
2096
        if (opts_min >= (recording_time / 1000000.0))
2097
            break;
2098

    
2099
        /* finish if limit size exhausted */
2100
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2101
            break;
2102

    
2103
        /* read a frame from it and output it in the fifo */
2104
        is = input_files[file_index];
2105
        ret= av_read_frame(is, &pkt);
2106
        if(ret == AVERROR(EAGAIN) && strcmp(is->iformat->name, "ffm")){
2107
            no_packet[file_index]=1;
2108
            no_packet_count++;
2109
            continue;
2110
        }
2111
        if (ret < 0) {
2112
            file_table[file_index].eof_reached = 1;
2113
            if (opt_shortest)
2114
                break;
2115
            else
2116
                continue;
2117
        }
2118

    
2119
        no_packet_count=0;
2120
        memset(no_packet, 0, sizeof(no_packet));
2121

    
2122
        if (do_pkt_dump) {
2123
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2124
        }
2125
        /* the following test is needed in case new streams appear
2126
           dynamically in stream : we ignore them */
2127
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2128
            goto discard_packet;
2129
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2130
        ist = ist_table[ist_index];
2131
        if (ist->discard)
2132
            goto discard_packet;
2133

    
2134
        if (pkt.dts != AV_NOPTS_VALUE)
2135
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2136
        if (pkt.pts != AV_NOPTS_VALUE)
2137
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2138

    
2139
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2140
            if(pkt.pts != AV_NOPTS_VALUE)
2141
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2142
            if(pkt.dts != AV_NOPTS_VALUE)
2143
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2144
        }
2145

    
2146
//        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);
2147
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2148
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2149
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2150
            int64_t delta= pkt_dts - ist->next_pts;
2151
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2152
                input_files_ts_offset[ist->file_index]-= delta;
2153
                if (verbose > 2)
2154
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2155
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2156
                if(pkt.pts != AV_NOPTS_VALUE)
2157
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2158
            }
2159
        }
2160

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

    
2164
            if (verbose >= 0)
2165
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2166
                        ist->file_index, ist->index);
2167
            if (exit_on_error)
2168
                av_exit(1);
2169
            av_free_packet(&pkt);
2170
            goto redo;
2171
        }
2172

    
2173
    discard_packet:
2174
        av_free_packet(&pkt);
2175

    
2176
        /* dump report by using the output first video and audio streams */
2177
        print_report(output_files, ost_table, nb_ostreams, 0);
2178
    }
2179

    
2180
    /* at the end of stream, we must flush the decoder buffers */
2181
    for(i=0;i<nb_istreams;i++) {
2182
        ist = ist_table[i];
2183
        if (ist->decoding_needed) {
2184
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2185
        }
2186
    }
2187

    
2188
    term_exit();
2189

    
2190
    /* write the trailer if needed and close file */
2191
    for(i=0;i<nb_output_files;i++) {
2192
        os = output_files[i];
2193
        av_write_trailer(os);
2194
    }
2195

    
2196
    /* dump report by using the first video and audio streams */
2197
    print_report(output_files, ost_table, nb_ostreams, 1);
2198

    
2199
    /* close each encoder */
2200
    for(i=0;i<nb_ostreams;i++) {
2201
        ost = ost_table[i];
2202
        if (ost->encoding_needed) {
2203
            av_freep(&ost->st->codec->stats_in);
2204
            avcodec_close(ost->st->codec);
2205
        }
2206
    }
2207

    
2208
    /* close each decoder */
2209
    for(i=0;i<nb_istreams;i++) {
2210
        ist = ist_table[i];
2211
        if (ist->decoding_needed) {
2212
            avcodec_close(ist->st->codec);
2213
        }
2214
    }
2215

    
2216
    /* finished ! */
2217

    
2218
    ret = 0;
2219
 fail1:
2220
    av_freep(&bit_buffer);
2221
    av_free(file_table);
2222

    
2223
    if (ist_table) {
2224
        for(i=0;i<nb_istreams;i++) {
2225
            ist = ist_table[i];
2226
            av_free(ist);
2227
        }
2228
        av_free(ist_table);
2229
    }
2230
    if (ost_table) {
2231
        for(i=0;i<nb_ostreams;i++) {
2232
            ost = ost_table[i];
2233
            if (ost) {
2234
                if (ost->logfile) {
2235
                    fclose(ost->logfile);
2236
                    ost->logfile = NULL;
2237
                }
2238
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2239
                                             initialized but set to zero */
2240
                av_free(ost->pict_tmp.data[0]);
2241
                if (ost->video_resample)
2242
                    sws_freeContext(ost->img_resample_ctx);
2243
                if (ost->resample)
2244
                    audio_resample_close(ost->resample);
2245
                if (ost->reformat_ctx)
2246
                    av_audio_convert_free(ost->reformat_ctx);
2247
                av_free(ost);
2248
            }
2249
        }
2250
        av_free(ost_table);
2251
    }
2252
    return ret;
2253
 fail:
2254
    ret = AVERROR(ENOMEM);
2255
    goto fail1;
2256
}
2257

    
2258
#if 0
2259
int file_read(const char *filename)
2260
{
2261
    URLContext *h;
2262
    unsigned char buffer[1024];
2263
    int len, i;
2264

2265
    if (url_open(&h, filename, O_RDONLY) < 0) {
2266
        printf("could not open '%s'\n", filename);
2267
        return -1;
2268
    }
2269
    for(;;) {
2270
        len = url_read(h, buffer, sizeof(buffer));
2271
        if (len <= 0)
2272
            break;
2273
        for(i=0;i<len;i++) putchar(buffer[i]);
2274
    }
2275
    url_close(h);
2276
    return 0;
2277
}
2278
#endif
2279

    
2280
static void opt_format(const char *arg)
2281
{
2282
    /* compatibility stuff for pgmyuv */
2283
    if (!strcmp(arg, "pgmyuv")) {
2284
        pgmyuv_compatibility_hack=1;
2285
//        opt_image_format(arg);
2286
        arg = "image2";
2287
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2288
    }
2289

    
2290
    file_iformat = av_find_input_format(arg);
2291
    file_oformat = guess_format(arg, NULL, NULL);
2292
    if (!file_iformat && !file_oformat) {
2293
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2294
        av_exit(1);
2295
    }
2296
}
2297

    
2298
static void opt_video_rc_override_string(const char *arg)
2299
{
2300
    video_rc_override_string = arg;
2301
}
2302

    
2303
static int opt_me_threshold(const char *opt, const char *arg)
2304
{
2305
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2306
    return 0;
2307
}
2308

    
2309
static int opt_verbose(const char *opt, const char *arg)
2310
{
2311
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2312
    av_log_set_level(verbose);
2313
    return 0;
2314
}
2315

    
2316
static int opt_frame_rate(const char *opt, const char *arg)
2317
{
2318
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2319
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2320
        av_exit(1);
2321
    }
2322
    return 0;
2323
}
2324

    
2325
static int opt_bitrate(const char *opt, const char *arg)
2326
{
2327
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2328

    
2329
    opt_default(opt, arg);
2330

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

    
2334
    return 0;
2335
}
2336

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

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

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

    
2391
static void opt_frame_crop_right(const char *arg)
2392
{
2393
    frame_rightBand = atoi(arg);
2394
    if (frame_rightBand < 0) {
2395
        fprintf(stderr, "Incorrect right crop size\n");
2396
        av_exit(1);
2397
    }
2398
    if ((frame_rightBand % 2) != 0) {
2399
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2400
        av_exit(1);
2401
    }
2402
    if ((frame_rightBand) >= frame_width){
2403
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2404
        av_exit(1);
2405
    }
2406
    frame_width -= frame_rightBand;
2407
}
2408

    
2409
static void opt_frame_size(const char *arg)
2410
{
2411
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2412
        fprintf(stderr, "Incorrect frame size\n");
2413
        av_exit(1);
2414
    }
2415
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2416
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2417
        av_exit(1);
2418
    }
2419
}
2420

    
2421

    
2422
#define SCALEBITS 10
2423
#define ONE_HALF  (1 << (SCALEBITS - 1))
2424
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2425

    
2426
#define RGB_TO_Y(r, g, b) \
2427
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2428
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2429

    
2430
#define RGB_TO_U(r1, g1, b1, shift)\
2431
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2432
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2433

    
2434
#define RGB_TO_V(r1, g1, b1, shift)\
2435
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2436
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2437

    
2438
static void opt_pad_color(const char *arg) {
2439
    /* Input is expected to be six hex digits similar to
2440
       how colors are expressed in html tags (but without the #) */
2441
    int rgb = strtol(arg, NULL, 16);
2442
    int r,g,b;
2443

    
2444
    r = (rgb >> 16);
2445
    g = ((rgb >> 8) & 255);
2446
    b = (rgb & 255);
2447

    
2448
    padcolor[0] = RGB_TO_Y(r,g,b);
2449
    padcolor[1] = RGB_TO_U(r,g,b,0);
2450
    padcolor[2] = RGB_TO_V(r,g,b,0);
2451
}
2452

    
2453
static void opt_frame_pad_top(const char *arg)
2454
{
2455
    frame_padtop = atoi(arg);
2456
    if (frame_padtop < 0) {
2457
        fprintf(stderr, "Incorrect top pad size\n");
2458
        av_exit(1);
2459
    }
2460
    if ((frame_padtop % 2) != 0) {
2461
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2462
        av_exit(1);
2463
    }
2464
}
2465

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

    
2479

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

    
2493

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

    
2507
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2508
{
2509
    int i;
2510
    char fmt_str[128];
2511
    for (i=-1; i < nb_fmts; i++) {
2512
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2513
        fprintf(stdout, "%s\n", fmt_str);
2514
    }
2515
}
2516

    
2517
static void opt_frame_pix_fmt(const char *arg)
2518
{
2519
    if (strcmp(arg, "list"))
2520
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2521
    else {
2522
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2523
        av_exit(0);
2524
    }
2525
}
2526

    
2527
static void opt_frame_aspect_ratio(const char *arg)
2528
{
2529
    int x = 0, y = 0;
2530
    double ar = 0;
2531
    const char *p;
2532
    char *end;
2533

    
2534
    p = strchr(arg, ':');
2535
    if (p) {
2536
        x = strtol(arg, &end, 10);
2537
        if (end == p)
2538
            y = strtol(end+1, &end, 10);
2539
        if (x > 0 && y > 0)
2540
            ar = (double)x / (double)y;
2541
    } else
2542
        ar = strtod(arg, NULL);
2543

    
2544
    if (!ar) {
2545
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2546
        av_exit(1);
2547
    }
2548
    frame_aspect_ratio = ar;
2549
}
2550

    
2551
static int opt_metadata(const char *opt, const char *arg)
2552
{
2553
    char *mid= strchr(arg, '=');
2554

    
2555
    if(!mid){
2556
        fprintf(stderr, "Missing =\n");
2557
        av_exit(1);
2558
    }
2559
    *mid++= 0;
2560

    
2561
    metadata_count++;
2562
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2563
    metadata[metadata_count-1].key  = av_strdup(arg);
2564
    metadata[metadata_count-1].value= av_strdup(mid);
2565

    
2566
    return 0;
2567
}
2568

    
2569
static void opt_qscale(const char *arg)
2570
{
2571
    video_qscale = atof(arg);
2572
    if (video_qscale <= 0 ||
2573
        video_qscale > 255) {
2574
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2575
        av_exit(1);
2576
    }
2577
}
2578

    
2579
static void opt_top_field_first(const char *arg)
2580
{
2581
    top_field_first= atoi(arg);
2582
}
2583

    
2584
static int opt_thread_count(const char *opt, const char *arg)
2585
{
2586
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2587
#if !HAVE_THREADS
2588
    if (verbose >= 0)
2589
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2590
#endif
2591
    return 0;
2592
}
2593

    
2594
static void opt_audio_sample_fmt(const char *arg)
2595
{
2596
    if (strcmp(arg, "list"))
2597
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2598
    else {
2599
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2600
        av_exit(0);
2601
    }
2602
}
2603

    
2604
static int opt_audio_rate(const char *opt, const char *arg)
2605
{
2606
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2607
    return 0;
2608
}
2609

    
2610
static int opt_audio_channels(const char *opt, const char *arg)
2611
{
2612
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2613
    return 0;
2614
}
2615

    
2616
static void opt_video_channel(const char *arg)
2617
{
2618
    video_channel = strtol(arg, NULL, 0);
2619
}
2620

    
2621
static void opt_video_standard(const char *arg)
2622
{
2623
    video_standard = av_strdup(arg);
2624
}
2625

    
2626
static void opt_codec(int *pstream_copy, char **pcodec_name,
2627
                      int codec_type, const char *arg)
2628
{
2629
    av_freep(pcodec_name);
2630
    if (!strcmp(arg, "copy")) {
2631
        *pstream_copy = 1;
2632
    } else {
2633
        *pcodec_name = av_strdup(arg);
2634
    }
2635
}
2636

    
2637
static void opt_audio_codec(const char *arg)
2638
{
2639
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2640
}
2641

    
2642
static void opt_audio_tag(const char *arg)
2643
{
2644
    char *tail;
2645
    audio_codec_tag= strtol(arg, &tail, 0);
2646

    
2647
    if(!tail || *tail)
2648
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2649
}
2650

    
2651
static void opt_video_tag(const char *arg)
2652
{
2653
    char *tail;
2654
    video_codec_tag= strtol(arg, &tail, 0);
2655

    
2656
    if(!tail || *tail)
2657
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2658
}
2659

    
2660
static void opt_video_codec(const char *arg)
2661
{
2662
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2663
}
2664

    
2665
static void opt_subtitle_codec(const char *arg)
2666
{
2667
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2668
}
2669

    
2670
static void opt_map(const char *arg)
2671
{
2672
    AVStreamMap *m;
2673
    char *p;
2674

    
2675
    m = &stream_maps[nb_stream_maps++];
2676

    
2677
    m->file_index = strtol(arg, &p, 0);
2678
    if (*p)
2679
        p++;
2680

    
2681
    m->stream_index = strtol(p, &p, 0);
2682
    if (*p) {
2683
        p++;
2684
        m->sync_file_index = strtol(p, &p, 0);
2685
        if (*p)
2686
            p++;
2687
        m->sync_stream_index = strtol(p, &p, 0);
2688
    } else {
2689
        m->sync_file_index = m->file_index;
2690
        m->sync_stream_index = m->stream_index;
2691
    }
2692
}
2693

    
2694
static void opt_map_meta_data(const char *arg)
2695
{
2696
    AVMetaDataMap *m;
2697
    char *p;
2698

    
2699
    m = &meta_data_maps[nb_meta_data_maps++];
2700

    
2701
    m->out_file = strtol(arg, &p, 0);
2702
    if (*p)
2703
        p++;
2704

    
2705
    m->in_file = strtol(p, &p, 0);
2706
}
2707

    
2708
static void opt_input_ts_scale(const char *arg)
2709
{
2710
    unsigned int stream;
2711
    double scale;
2712
    char *p;
2713

    
2714
    stream = strtol(arg, &p, 0);
2715
    if (*p)
2716
        p++;
2717
    scale= strtod(p, &p);
2718

    
2719
    if(stream >= MAX_STREAMS)
2720
        av_exit(1);
2721

    
2722
    input_files_ts_scale[nb_input_files][stream]= scale;
2723
}
2724

    
2725
static int opt_recording_time(const char *opt, const char *arg)
2726
{
2727
    recording_time = parse_time_or_die(opt, arg, 1);
2728
    return 0;
2729
}
2730

    
2731
static int opt_start_time(const char *opt, const char *arg)
2732
{
2733
    start_time = parse_time_or_die(opt, arg, 1);
2734
    return 0;
2735
}
2736

    
2737
static int opt_rec_timestamp(const char *opt, const char *arg)
2738
{
2739
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2740
    return 0;
2741
}
2742

    
2743
static int opt_input_ts_offset(const char *opt, const char *arg)
2744
{
2745
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2746
    return 0;
2747
}
2748

    
2749
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2750
{
2751
    const char *codec_string = encoder ? "encoder" : "decoder";
2752
    AVCodec *codec;
2753

    
2754
    if(!name)
2755
        return CODEC_ID_NONE;
2756
    codec = encoder ?
2757
        avcodec_find_encoder_by_name(name) :
2758
        avcodec_find_decoder_by_name(name);
2759
    if(!codec) {
2760
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2761
        av_exit(1);
2762
    }
2763
    if(codec->type != type) {
2764
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2765
        av_exit(1);
2766
    }
2767
    return codec->id;
2768
}
2769

    
2770
static void opt_input_file(const char *filename)
2771
{
2772
    AVFormatContext *ic;
2773
    AVFormatParameters params, *ap = &params;
2774
    int err, i, ret, rfps, rfps_base;
2775
    int64_t timestamp;
2776

    
2777
    if (!strcmp(filename, "-"))
2778
        filename = "pipe:";
2779

    
2780
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2781
                    !strcmp(filename, "/dev/stdin");
2782

    
2783
    /* get default parameters from command line */
2784
    ic = avformat_alloc_context();
2785

    
2786
    memset(ap, 0, sizeof(*ap));
2787
    ap->prealloced_context = 1;
2788
    ap->sample_rate = audio_sample_rate;
2789
    ap->channels = audio_channels;
2790
    ap->time_base.den = frame_rate.num;
2791
    ap->time_base.num = frame_rate.den;
2792
    ap->width = frame_width + frame_padleft + frame_padright;
2793
    ap->height = frame_height + frame_padtop + frame_padbottom;
2794
    ap->pix_fmt = frame_pix_fmt;
2795
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2796
    ap->channel = video_channel;
2797
    ap->standard = video_standard;
2798
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2799
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2800
    if(pgmyuv_compatibility_hack)
2801
        ap->video_codec_id= CODEC_ID_PGMYUV;
2802

    
2803
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2804

    
2805
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2806
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2807
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2808

    
2809
    /* open the input file with generic libav function */
2810
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2811
    if (err < 0) {
2812
        print_error(filename, err);
2813
        av_exit(1);
2814
    }
2815
    if(opt_programid) {
2816
        int i;
2817
        for(i=0; i<ic->nb_programs; i++)
2818
            if(ic->programs[i]->id != opt_programid)
2819
                ic->programs[i]->discard = AVDISCARD_ALL;
2820
    }
2821

    
2822
    ic->loop_input = loop_input;
2823

    
2824
    /* If not enough info to get the stream parameters, we decode the
2825
       first frames to get it. (used in mpeg case for example) */
2826
    ret = av_find_stream_info(ic);
2827
    if (ret < 0 && verbose >= 0) {
2828
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2829
        av_exit(1);
2830
    }
2831

    
2832
    timestamp = start_time;
2833
    /* add the stream start time */
2834
    if (ic->start_time != AV_NOPTS_VALUE)
2835
        timestamp += ic->start_time;
2836

    
2837
    /* if seeking requested, we execute it */
2838
    if (start_time != 0) {
2839
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2840
        if (ret < 0) {
2841
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2842
                    filename, (double)timestamp / AV_TIME_BASE);
2843
        }
2844
        /* reset seek info */
2845
        start_time = 0;
2846
    }
2847

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

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

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

    
2888
                    (float)rfps / rfps_base, rfps, rfps_base);
2889
            }
2890
            /* update the current frame rate to match the stream frame rate */
2891
            frame_rate.num = rfps;
2892
            frame_rate.den = rfps_base;
2893

    
2894
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2895
            if(video_disable)
2896
                ic->streams[i]->discard= AVDISCARD_ALL;
2897
            else if(video_discard)
2898
                ic->streams[i]->discard= video_discard;
2899
            break;
2900
        case CODEC_TYPE_DATA:
2901
            break;
2902
        case CODEC_TYPE_SUBTITLE:
2903
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2904
            if(subtitle_disable)
2905
                ic->streams[i]->discard = AVDISCARD_ALL;
2906
            break;
2907
        case CODEC_TYPE_ATTACHMENT:
2908
        case CODEC_TYPE_UNKNOWN:
2909
            nb_icodecs++;
2910
            break;
2911
        default:
2912
            abort();
2913
        }
2914
    }
2915

    
2916
    input_files[nb_input_files] = ic;
2917
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2918
    /* dump the file content */
2919
    if (verbose >= 0)
2920
        dump_format(ic, nb_input_files, filename, 0);
2921

    
2922
    nb_input_files++;
2923
    file_iformat = NULL;
2924
    file_oformat = NULL;
2925

    
2926
    video_channel = 0;
2927

    
2928
    av_freep(&video_codec_name);
2929
    av_freep(&audio_codec_name);
2930
    av_freep(&subtitle_codec_name);
2931
}
2932

    
2933
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2934
                                         int *has_subtitle_ptr)
2935
{
2936
    int has_video, has_audio, has_subtitle, i, j;
2937
    AVFormatContext *ic;
2938

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

    
2970
static void new_video_stream(AVFormatContext *oc)
2971
{
2972
    AVStream *st;
2973
    AVCodecContext *video_enc;
2974
    int codec_id;
2975

    
2976
    st = av_new_stream(oc, oc->nb_streams);
2977
    if (!st) {
2978
        fprintf(stderr, "Could not alloc stream\n");
2979
        av_exit(1);
2980
    }
2981
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2982
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2983
    video_bitstream_filters= NULL;
2984

    
2985
    if(thread_count>1)
2986
        avcodec_thread_init(st->codec, thread_count);
2987

    
2988
    video_enc = st->codec;
2989

    
2990
    if(video_codec_tag)
2991
        video_enc->codec_tag= video_codec_tag;
2992

    
2993
    if(   (video_global_header&1)
2994
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2995
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2996
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2997
    }
2998
    if(video_global_header&2){
2999
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3000
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3001
    }
3002

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

    
3014
        if (video_codec_name) {
3015
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3016
            codec = avcodec_find_encoder_by_name(video_codec_name);
3017
            output_codecs[nb_ocodecs] = codec;
3018
        } else {
3019
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3020
            codec = avcodec_find_encoder(codec_id);
3021
        }
3022

    
3023
        video_enc->codec_id = codec_id;
3024

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

    
3027
        if (codec && codec->supported_framerates && !force_fps)
3028
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3029
        video_enc->time_base.den = fps.num;
3030
        video_enc->time_base.num = fps.den;
3031

    
3032
        video_enc->width = frame_width + frame_padright + frame_padleft;
3033
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3034
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3035
        video_enc->pix_fmt = frame_pix_fmt;
3036
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3037

    
3038
        if(codec && codec->pix_fmts){
3039
            const enum PixelFormat *p= codec->pix_fmts;
3040
            for(; *p!=-1; p++){
3041
                if(*p == video_enc->pix_fmt)
3042
                    break;
3043
            }
3044
            if(*p == -1)
3045
                video_enc->pix_fmt = codec->pix_fmts[0];
3046
        }
3047

    
3048
        if (intra_only)
3049
            video_enc->gop_size = 0;
3050
        if (video_qscale || same_quality) {
3051
            video_enc->flags |= CODEC_FLAG_QSCALE;
3052
            video_enc->global_quality=
3053
                st->quality = FF_QP2LAMBDA * video_qscale;
3054
        }
3055

    
3056
        if(intra_matrix)
3057
            video_enc->intra_matrix = intra_matrix;
3058
        if(inter_matrix)
3059
            video_enc->inter_matrix = inter_matrix;
3060

    
3061
        video_enc->thread_count = thread_count;
3062
        p= video_rc_override_string;
3063
        for(i=0; p; i++){
3064
            int start, end, q;
3065
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3066
            if(e!=3){
3067
                fprintf(stderr, "error parsing rc_override\n");
3068
                av_exit(1);
3069
            }
3070
            video_enc->rc_override=
3071
                av_realloc(video_enc->rc_override,
3072
                           sizeof(RcOverride)*(i+1));
3073
            video_enc->rc_override[i].start_frame= start;
3074
            video_enc->rc_override[i].end_frame  = end;
3075
            if(q>0){
3076
                video_enc->rc_override[i].qscale= q;
3077
                video_enc->rc_override[i].quality_factor= 1.0;
3078
            }
3079
            else{
3080
                video_enc->rc_override[i].qscale= 0;
3081
                video_enc->rc_override[i].quality_factor= -q/100.0;
3082
            }
3083
            p= strchr(p, '/');
3084
            if(p) p++;
3085
        }
3086
        video_enc->rc_override_count=i;
3087
        if (!video_enc->rc_initial_buffer_occupancy)
3088
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3089
        video_enc->me_threshold= me_threshold;
3090
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3091

    
3092
        if (do_psnr)
3093
            video_enc->flags|= CODEC_FLAG_PSNR;
3094

    
3095
        /* two pass mode */
3096
        if (do_pass) {
3097
            if (do_pass == 1) {
3098
                video_enc->flags |= CODEC_FLAG_PASS1;
3099
            } else {
3100
                video_enc->flags |= CODEC_FLAG_PASS2;
3101
            }
3102
        }
3103
    }
3104
    nb_ocodecs++;
3105

    
3106
    /* reset some key parameters */
3107
    video_disable = 0;
3108
    av_freep(&video_codec_name);
3109
    video_stream_copy = 0;
3110
}
3111

    
3112
static void new_audio_stream(AVFormatContext *oc)
3113
{
3114
    AVStream *st;
3115
    AVCodecContext *audio_enc;
3116
    int codec_id;
3117

    
3118
    st = av_new_stream(oc, oc->nb_streams);
3119
    if (!st) {
3120
        fprintf(stderr, "Could not alloc stream\n");
3121
        av_exit(1);
3122
    }
3123
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3124

    
3125
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3126
    audio_bitstream_filters= NULL;
3127

    
3128
    if(thread_count>1)
3129
        avcodec_thread_init(st->codec, thread_count);
3130

    
3131
    audio_enc = st->codec;
3132
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3133

    
3134
    if(audio_codec_tag)
3135
        audio_enc->codec_tag= audio_codec_tag;
3136

    
3137
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3138
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3139
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3140
    }
3141
    if (audio_stream_copy) {
3142
        st->stream_copy = 1;
3143
        audio_enc->channels = audio_channels;
3144
    } else {
3145
        AVCodec *codec;
3146

    
3147
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3148

    
3149
        if (audio_codec_name) {
3150
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3151
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3152
            output_codecs[nb_ocodecs] = codec;
3153
        } else {
3154
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3155
            codec = avcodec_find_encoder(codec_id);
3156
        }
3157
        audio_enc->codec_id = codec_id;
3158

    
3159
        if (audio_qscale > QSCALE_NONE) {
3160
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3161
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3162
        }
3163
        audio_enc->thread_count = thread_count;
3164
        audio_enc->channels = audio_channels;
3165
        audio_enc->sample_fmt = audio_sample_fmt;
3166
        audio_enc->channel_layout = channel_layout;
3167

    
3168
        if(codec && codec->sample_fmts){
3169
            const enum SampleFormat *p= codec->sample_fmts;
3170
            for(; *p!=-1; p++){
3171
                if(*p == audio_enc->sample_fmt)
3172
                    break;
3173
            }
3174
            if(*p == -1)
3175
                audio_enc->sample_fmt = codec->sample_fmts[0];
3176
        }
3177
    }
3178
    nb_ocodecs++;
3179
    audio_enc->sample_rate = audio_sample_rate;
3180
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3181
    if (audio_language) {
3182
        av_metadata_set(&st->metadata, "language", audio_language);
3183
        av_free(audio_language);
3184
        audio_language = NULL;
3185
    }
3186

    
3187
    /* reset some key parameters */
3188
    audio_disable = 0;
3189
    av_freep(&audio_codec_name);
3190
    audio_stream_copy = 0;
3191
}
3192

    
3193
static void new_subtitle_stream(AVFormatContext *oc)
3194
{
3195
    AVStream *st;
3196
    AVCodecContext *subtitle_enc;
3197

    
3198
    st = av_new_stream(oc, oc->nb_streams);
3199
    if (!st) {
3200
        fprintf(stderr, "Could not alloc stream\n");
3201
        av_exit(1);
3202
    }
3203
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3204

    
3205
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3206
    subtitle_bitstream_filters= NULL;
3207

    
3208
    subtitle_enc = st->codec;
3209
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3210
    if (subtitle_stream_copy) {
3211
        st->stream_copy = 1;
3212
    } else {
3213
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3214
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3215
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3216
    }
3217
    nb_ocodecs++;
3218

    
3219
    if (subtitle_language) {
3220
        av_metadata_set(&st->metadata, "language", subtitle_language);
3221
        av_free(subtitle_language);
3222
        subtitle_language = NULL;
3223
    }
3224

    
3225
    subtitle_disable = 0;
3226
    av_freep(&subtitle_codec_name);
3227
    subtitle_stream_copy = 0;
3228
}
3229

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

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

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

    
3263
static void opt_output_file(const char *filename)
3264
{
3265
    AVFormatContext *oc;
3266
    int use_video, use_audio, use_subtitle;
3267
    int input_has_video, input_has_audio, input_has_subtitle;
3268
    AVFormatParameters params, *ap = &params;
3269

    
3270
    if (!strcmp(filename, "-"))
3271
        filename = "pipe:";
3272

    
3273
    oc = avformat_alloc_context();
3274

    
3275
    if (!file_oformat) {
3276
        file_oformat = guess_format(NULL, filename, NULL);
3277
        if (!file_oformat) {
3278
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3279
                    filename);
3280
            av_exit(1);
3281
        }
3282
    }
3283

    
3284
    oc->oformat = file_oformat;
3285
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3286

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

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

    
3314
        /* manual disable */
3315
        if (audio_disable) {
3316
            use_audio = 0;
3317
        }
3318
        if (video_disable) {
3319
            use_video = 0;
3320
        }
3321
        if (subtitle_disable) {
3322
            use_subtitle = 0;
3323
        }
3324

    
3325
        if (use_video) {
3326
            new_video_stream(oc);
3327
        }
3328

    
3329
        if (use_audio) {
3330
            new_audio_stream(oc);
3331
        }
3332

    
3333
        if (use_subtitle) {
3334
            new_subtitle_stream(oc);
3335
        }
3336

    
3337
        oc->timestamp = rec_timestamp;
3338

    
3339
        for(; metadata_count>0; metadata_count--){
3340
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3341
                                           metadata[metadata_count-1].value);
3342
        }
3343
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3344
    }
3345

    
3346
    output_files[nb_output_files++] = oc;
3347

    
3348
    /* check filename in case of an image number is expected */
3349
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3350
        if (!av_filename_number_test(oc->filename)) {
3351
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3352
            av_exit(1);
3353
        }
3354
    }
3355

    
3356
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3357
        /* test if it already exists to avoid loosing precious files */
3358
        if (!file_overwrite &&
3359
            (strchr(filename, ':') == NULL ||
3360
             filename[1] == ':' ||
3361
             av_strstart(filename, "file:", NULL))) {
3362
            if (url_exist(filename)) {
3363
                int c;
3364

    
3365
                if (!using_stdin) {
3366
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3367
                    fflush(stderr);
3368
                    c = getchar();
3369
                    if (toupper(c) != 'Y') {
3370
                        fprintf(stderr, "Not overwriting - exiting\n");
3371
                        av_exit(1);
3372
                    }
3373
                }
3374
                else {
3375
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3376
                    av_exit(1);
3377
                }
3378
            }
3379
        }
3380

    
3381
        /* open the file */
3382
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3383
            fprintf(stderr, "Could not open '%s'\n", filename);
3384
            av_exit(1);
3385
        }
3386
    }
3387

    
3388
    memset(ap, 0, sizeof(*ap));
3389
    if (av_set_parameters(oc, ap) < 0) {
3390
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3391
                oc->filename);
3392
        av_exit(1);
3393
    }
3394

    
3395
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3396
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3397
    oc->loop_output = loop_output;
3398

    
3399
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3400

    
3401
    /* reset some options */
3402
    file_oformat = NULL;
3403
    file_iformat = NULL;
3404
}
3405

    
3406
/* same option as mencoder */
3407
static void opt_pass(const char *pass_str)
3408
{
3409
    int pass;
3410
    pass = atoi(pass_str);
3411
    if (pass != 1 && pass != 2) {
3412
        fprintf(stderr, "pass number can be only 1 or 2\n");
3413
        av_exit(1);
3414
    }
3415
    do_pass = pass;
3416
}
3417

    
3418
static int64_t getutime(void)
3419
{
3420
#if HAVE_GETRUSAGE
3421
    struct rusage rusage;
3422

    
3423
    getrusage(RUSAGE_SELF, &rusage);
3424
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3425
#elif HAVE_GETPROCESSTIMES
3426
    HANDLE proc;
3427
    FILETIME c, e, k, u;
3428
    proc = GetCurrentProcess();
3429
    GetProcessTimes(proc, &c, &e, &k, &u);
3430
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3431
#else
3432
    return av_gettime();
3433
#endif
3434
}
3435

    
3436
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3437
{
3438
    int i;
3439
    const char *p = str;
3440
    for(i = 0;; i++) {
3441
        dest[i] = atoi(p);
3442
        if(i == 63)
3443
            break;
3444
        p = strchr(p, ',');
3445
        if(!p) {
3446
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3447
            av_exit(1);
3448
        }
3449
        p++;
3450
    }
3451
}
3452

    
3453
static void opt_inter_matrix(const char *arg)
3454
{
3455
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3456
    parse_matrix_coeffs(inter_matrix, arg);
3457
}
3458

    
3459
static void opt_intra_matrix(const char *arg)
3460
{
3461
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3462
    parse_matrix_coeffs(intra_matrix, arg);
3463
}
3464

    
3465
/**
3466
 * Trivial log callback.
3467
 * Only suitable for show_help and similar since it lacks prefix handling.
3468
 */
3469
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3470
{
3471
    vfprintf(stdout, fmt, vl);
3472
}
3473

    
3474
static void show_help(void)
3475
{
3476
    av_log_set_callback(log_callback_help);
3477
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3478
           "Hyper fast Audio and Video encoder\n");
3479
    printf("\n");
3480
    show_help_options(options, "Main options:\n",
3481
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3482
    show_help_options(options, "\nAdvanced options:\n",
3483
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3484
                      OPT_EXPERT);
3485
    show_help_options(options, "\nVideo options:\n",
3486
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3487
                      OPT_VIDEO);
3488
    show_help_options(options, "\nAdvanced Video options:\n",
3489
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3490
                      OPT_VIDEO | OPT_EXPERT);
3491
    show_help_options(options, "\nAudio options:\n",
3492
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3493
                      OPT_AUDIO);
3494
    show_help_options(options, "\nAdvanced Audio options:\n",
3495
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3496
                      OPT_AUDIO | OPT_EXPERT);
3497
    show_help_options(options, "\nSubtitle options:\n",
3498
                      OPT_SUBTITLE | OPT_GRAB,
3499
                      OPT_SUBTITLE);
3500
    show_help_options(options, "\nAudio/Video grab options:\n",
3501
                      OPT_GRAB,
3502
                      OPT_GRAB);
3503
    printf("\n");
3504
    av_opt_show(avctx_opts[0], NULL);
3505
    printf("\n");
3506
    av_opt_show(avformat_opts, NULL);
3507
    printf("\n");
3508
    av_opt_show(sws_opts, NULL);
3509
}
3510

    
3511
static void opt_target(const char *arg)
3512
{
3513
    int norm = -1;
3514
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3515

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

    
3560
    if(norm < 0) {
3561
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3562
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3563
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3564
        av_exit(1);
3565
    }
3566

    
3567
    if(!strcmp(arg, "vcd")) {
3568

    
3569
        opt_video_codec("mpeg1video");
3570
        opt_audio_codec("mp2");
3571
        opt_format("vcd");
3572

    
3573
        opt_frame_size(norm ? "352x240" : "352x288");
3574
        opt_frame_rate(NULL, frame_rates[norm]);
3575
        opt_default("gop", norm ? "18" : "15");
3576

    
3577
        opt_default("b", "1150000");
3578
        opt_default("maxrate", "1150000");
3579
        opt_default("minrate", "1150000");
3580
        opt_default("bufsize", "327680"); // 40*1024*8;
3581

    
3582
        opt_default("ab", "224000");
3583
        audio_sample_rate = 44100;
3584
        audio_channels = 2;
3585

    
3586
        opt_default("packetsize", "2324");
3587
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3588

    
3589
        /* We have to offset the PTS, so that it is consistent with the SCR.
3590
           SCR starts at 36000, but the first two packs contain only padding
3591
           and the first pack from the other stream, respectively, may also have
3592
           been written before.
3593
           So the real data starts at SCR 36000+3*1200. */
3594
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3595
    } else if(!strcmp(arg, "svcd")) {
3596

    
3597
        opt_video_codec("mpeg2video");
3598
        opt_audio_codec("mp2");
3599
        opt_format("svcd");
3600

    
3601
        opt_frame_size(norm ? "480x480" : "480x576");
3602
        opt_frame_rate(NULL, frame_rates[norm]);
3603
        opt_default("gop", norm ? "18" : "15");
3604

    
3605
        opt_default("b", "2040000");
3606
        opt_default("maxrate", "2516000");
3607
        opt_default("minrate", "0"); //1145000;
3608
        opt_default("bufsize", "1835008"); //224*1024*8;
3609
        opt_default("flags", "+scan_offset");
3610

    
3611

    
3612
        opt_default("ab", "224000");
3613
        audio_sample_rate = 44100;
3614

    
3615
        opt_default("packetsize", "2324");
3616

    
3617
    } else if(!strcmp(arg, "dvd")) {
3618

    
3619
        opt_video_codec("mpeg2video");
3620
        opt_audio_codec("ac3");
3621
        opt_format("dvd");
3622

    
3623
        opt_frame_size(norm ? "720x480" : "720x576");
3624
        opt_frame_rate(NULL, frame_rates[norm]);
3625
        opt_default("gop", norm ? "18" : "15");
3626

    
3627
        opt_default("b", "6000000");
3628
        opt_default("maxrate", "9000000");
3629
        opt_default("minrate", "0"); //1500000;
3630
        opt_default("bufsize", "1835008"); //224*1024*8;
3631

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

    
3635
        opt_default("ab", "448000");
3636
        audio_sample_rate = 48000;
3637

    
3638
    } else if(!strncmp(arg, "dv", 2)) {
3639

    
3640
        opt_format("dv");
3641

    
3642
        opt_frame_size(norm ? "720x480" : "720x576");
3643
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3644
                                             (norm ? "yuv411p" : "yuv420p"));
3645
        opt_frame_rate(NULL, frame_rates[norm]);
3646

    
3647
        audio_sample_rate = 48000;
3648
        audio_channels = 2;
3649

    
3650
    } else {
3651
        fprintf(stderr, "Unknown target: %s\n", arg);
3652
        av_exit(1);
3653
    }
3654
}
3655

    
3656
static void opt_vstats_file (const char *arg)
3657
{
3658
    av_free (vstats_filename);
3659
    vstats_filename=av_strdup (arg);
3660
}
3661

    
3662
static void opt_vstats (void)
3663
{
3664
    char filename[40];
3665
    time_t today2 = time(NULL);
3666
    struct tm *today = localtime(&today2);
3667

    
3668
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3669
             today->tm_sec);
3670
    opt_vstats_file(filename);
3671
}
3672

    
3673
static int opt_bsf(const char *opt, const char *arg)
3674
{
3675
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3676
    AVBitStreamFilterContext **bsfp;
3677

    
3678
    if(!bsfc){
3679
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3680
        av_exit(1);
3681
    }
3682

    
3683
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3684
          *opt == 'a' ? &audio_bitstream_filters :
3685
                        &subtitle_bitstream_filters;
3686
    while(*bsfp)
3687
        bsfp= &(*bsfp)->next;
3688

    
3689
    *bsfp= bsfc;
3690

    
3691
    return 0;
3692
}
3693

    
3694
static int opt_preset(const char *opt, const char *arg)
3695
{
3696
    FILE *f=NULL;
3697
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3698
    int i;
3699
    const char *base[2]= { getenv("HOME"),
3700
                           FFMPEG_DATADIR,
3701
                         };
3702

    
3703
    for(i=!base[0]; i<2 && !f; i++){
3704
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3705
        f= fopen(filename, "r");
3706
        if(!f){
3707
            char *codec_name= *opt == 'v' ? video_codec_name :
3708
                              *opt == 'a' ? audio_codec_name :
3709
                                            subtitle_codec_name;
3710
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3711
            f= fopen(filename, "r");
3712
        }
3713
    }
3714
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3715
              is_dos_path(arg))){
3716
        av_strlcpy(filename, arg, sizeof(filename));
3717
        f= fopen(filename, "r");
3718
    }
3719

    
3720
    if(!f){
3721
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3722
        av_exit(1);
3723
    }
3724

    
3725
    while(!feof(f)){
3726
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3727
        if(line[0] == '#' && !e)
3728
            continue;
3729
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3730
        if(e){
3731
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3732
            av_exit(1);
3733
        }
3734
        if(!strcmp(tmp, "acodec")){
3735
            opt_audio_codec(tmp2);
3736
        }else if(!strcmp(tmp, "vcodec")){
3737
            opt_video_codec(tmp2);
3738
        }else if(!strcmp(tmp, "scodec")){
3739
            opt_subtitle_codec(tmp2);
3740
        }else if(opt_default(tmp, tmp2) < 0){
3741
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3742
            av_exit(1);
3743
        }
3744
    }
3745

    
3746
    fclose(f);
3747

    
3748
    return 0;
3749
}
3750

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

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

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

    
3849
    /* subtitle options */
3850
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3851
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3852
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3853
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3854

    
3855
    /* grab options */
3856
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3857
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3858
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3859

    
3860
    /* muxer options */
3861
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3862
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3863

    
3864
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3865
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3866
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3867

    
3868
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3869
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3870
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3871

    
3872
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3873
    { NULL, },
3874
};
3875

    
3876
int main(int argc, char **argv)
3877
{
3878
    int i;
3879
    int64_t ti;
3880

    
3881
    avcodec_register_all();
3882
    avdevice_register_all();
3883
    av_register_all();
3884

    
3885
    if(isatty(STDIN_FILENO))
3886
        url_set_interrupt_cb(decode_interrupt_cb);
3887

    
3888
    for(i=0; i<CODEC_TYPE_NB; i++){
3889
        avctx_opts[i]= avcodec_alloc_context2(i);
3890
    }
3891
    avformat_opts = avformat_alloc_context();
3892
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3893

    
3894
    show_banner();
3895

    
3896
    /* parse options */
3897
    parse_options(argc, argv, options, opt_output_file);
3898

    
3899
    /* file converter / grab */
3900
    if (nb_output_files <= 0) {
3901
        fprintf(stderr, "At least one output file must be specified\n");
3902
        av_exit(1);
3903
    }
3904

    
3905
    if (nb_input_files == 0) {
3906
        fprintf(stderr, "At least one input file must be specified\n");
3907
        av_exit(1);
3908
    }
3909

    
3910
    ti = getutime();
3911
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3912
                  stream_maps, nb_stream_maps) < 0)
3913
        av_exit(1);
3914
    ti = getutime() - ti;
3915
    if (do_benchmark) {
3916
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3917
    }
3918

    
3919
    return av_exit(0);
3920
}