Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ b716c6c6

History | View | Annotate | Download (141 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
static int subtitle_codec_tag = 0;
166

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

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

    
197
static int rate_emu = 0;
198

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

    
202
static int audio_volume = 256;
203

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

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

    
221
static unsigned int sws_flags = SWS_BICUBIC;
222

    
223
static int64_t timer_start;
224

    
225
static uint8_t *audio_buf;
226
static uint8_t *audio_out;
227
static uint8_t *audio_out2;
228

    
229
static short *samples;
230

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

    
236
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
237

    
238
struct AVInputStream;
239

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

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

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

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

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

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

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

    
299
#if HAVE_TERMIOS_H
300

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

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

    
312
static volatile sig_atomic_t received_sigterm = 0;
313

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

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

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

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

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

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

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

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

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

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

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

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

    
416
    av_free(intra_matrix);
417
    av_free(inter_matrix);
418

    
419
    if (vstats_file)
420
        fclose(vstats_file);
421
    av_free(vstats_filename);
422

    
423
    av_free(opt_names);
424

    
425
    av_free(video_codec_name);
426
    av_free(audio_codec_name);
427
    av_free(subtitle_codec_name);
428

    
429
    av_free(video_standard);
430

    
431
#if CONFIG_POWERPC_PERF
432
    void powerpc_display_perf_report(void);
433
    powerpc_display_perf_report();
434
#endif /* CONFIG_POWERPC_PERF */
435

    
436
    for (i=0;i<CODEC_TYPE_NB;i++)
437
        av_free(avcodec_opts[i]);
438
    av_free(avformat_opts);
439
    av_free(sws_opts);
440
    av_free(audio_buf);
441
    av_free(audio_out);
442
    av_free(audio_out2);
443
    av_free(samples);
444

    
445
    if (received_sigterm) {
446
        fprintf(stderr,
447
            "Received signal %d: terminating.\n",
448
            (int) received_sigterm);
449
        exit (255);
450
    }
451

    
452
    exit(ret); /* not all OS-es handle main() return value */
453
    return ret;
454
}
455

    
456
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
457
{
458
    int i, err;
459
    AVFormatContext *ic;
460
    int nopts = 0;
461

    
462
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
463
    if (err < 0)
464
        return err;
465
    /* copy stream format */
466
    s->nb_streams = ic->nb_streams;
467
    for(i=0;i<ic->nb_streams;i++) {
468
        AVStream *st;
469

    
470
        // FIXME: a more elegant solution is needed
471
        st = av_mallocz(sizeof(AVStream));
472
        memcpy(st, ic->streams[i], sizeof(AVStream));
473
        st->codec = avcodec_alloc_context();
474
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
475
        s->streams[i] = st;
476

    
477
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
478
            st->stream_copy = 1;
479
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
480
            st->stream_copy = 1;
481

    
482
        if(!st->codec->thread_count)
483
            st->codec->thread_count = 1;
484
        if(st->codec->thread_count>1)
485
            avcodec_thread_init(st->codec, st->codec->thread_count);
486

    
487
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
488
            nopts = 1;
489
    }
490

    
491
    if (!nopts)
492
        s->timestamp = av_gettime();
493

    
494
    av_close_input_file(ic);
495
    return 0;
496
}
497

    
498
static double
499
get_sync_ipts(const AVOutputStream *ost)
500
{
501
    const AVInputStream *ist = ost->sync_ist;
502
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
503
}
504

    
505
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
506
    int ret;
507

    
508
    while(bsfc){
509
        AVPacket new_pkt= *pkt;
510
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
511
                                          &new_pkt.data, &new_pkt.size,
512
                                          pkt->data, pkt->size,
513
                                          pkt->flags & PKT_FLAG_KEY);
514
        if(a>0){
515
            av_free_packet(pkt);
516
            new_pkt.destruct= av_destruct_packet;
517
        } else if(a<0){
518
            fprintf(stderr, "%s failed for stream %d, codec %s",
519
                    bsfc->filter->name, pkt->stream_index,
520
                    avctx->codec ? avctx->codec->name : "copy");
521
            print_error("", a);
522
            if (exit_on_error)
523
                av_exit(1);
524
        }
525
        *pkt= new_pkt;
526

    
527
        bsfc= bsfc->next;
528
    }
529

    
530
    ret= av_interleaved_write_frame(s, pkt);
531
    if(ret < 0){
532
        print_error("av_interleaved_write_frame()", ret);
533
        av_exit(1);
534
    }
535
}
536

    
537
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
538

    
539
static void do_audio_out(AVFormatContext *s,
540
                         AVOutputStream *ost,
541
                         AVInputStream *ist,
542
                         unsigned char *buf, int size)
543
{
544
    uint8_t *buftmp;
545
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
546

    
547
    int size_out, frame_bytes, ret;
548
    AVCodecContext *enc= ost->st->codec;
549
    AVCodecContext *dec= ist->st->codec;
550
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
551
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
552

    
553
    /* SC: dynamic allocation of buffers */
554
    if (!audio_buf)
555
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
556
    if (!audio_out)
557
        audio_out = av_malloc(audio_out_size);
558
    if (!audio_buf || !audio_out)
559
        return;               /* Should signal an error ! */
560

    
561
    if (enc->channels != dec->channels)
562
        ost->audio_resample = 1;
563

    
564
    if (ost->audio_resample && !ost->resample) {
565
        if (dec->sample_fmt != SAMPLE_FMT_S16)
566
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
567
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
568
                                               enc->sample_rate, dec->sample_rate,
569
                                               enc->sample_fmt,  dec->sample_fmt,
570
                                               16, 10, 0, 0.8);
571
        if (!ost->resample) {
572
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
573
                    dec->channels, dec->sample_rate,
574
                    enc->channels, enc->sample_rate);
575
            av_exit(1);
576
        }
577
    }
578

    
579
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
580
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
581
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
582
        if (!audio_out2)
583
            audio_out2 = av_malloc(audio_out_size);
584
        if (!audio_out2)
585
            av_exit(1);
586
        if (ost->reformat_ctx)
587
            av_audio_convert_free(ost->reformat_ctx);
588
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
589
                                                   dec->sample_fmt, 1, NULL, 0);
590
        if (!ost->reformat_ctx) {
591
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
592
                avcodec_get_sample_fmt_name(dec->sample_fmt),
593
                avcodec_get_sample_fmt_name(enc->sample_fmt));
594
            av_exit(1);
595
        }
596
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
597
    }
598

    
599
    if(audio_sync_method){
600
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
601
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
602
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
603
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
604

    
605
        //FIXME resample delay
606
        if(fabs(delta) > 50){
607
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
608
                if(byte_delta < 0){
609
                    byte_delta= FFMAX(byte_delta, -size);
610
                    size += byte_delta;
611
                    buf  -= byte_delta;
612
                    if(verbose > 2)
613
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
614
                    if(!size)
615
                        return;
616
                    ist->is_start=0;
617
                }else{
618
                    static uint8_t *input_tmp= NULL;
619
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
620

    
621
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
622
                        ist->is_start=0;
623
                    else
624
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
625

    
626
                    memset(input_tmp, 0, byte_delta);
627
                    memcpy(input_tmp + byte_delta, buf, size);
628
                    buf= input_tmp;
629
                    size += byte_delta;
630
                    if(verbose > 2)
631
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
632
                }
633
            }else if(audio_sync_method>1){
634
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
635
                assert(ost->audio_resample);
636
                if(verbose > 2)
637
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
638
//                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));
639
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
640
            }
641
        }
642
    }else
643
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
644
                        - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
645

    
646
    if (ost->audio_resample) {
647
        buftmp = audio_buf;
648
        size_out = audio_resample(ost->resample,
649
                                  (short *)buftmp, (short *)buf,
650
                                  size / (ist->st->codec->channels * isize));
651
        size_out = size_out * enc->channels * osize;
652
    } else {
653
        buftmp = buf;
654
        size_out = size;
655
    }
656

    
657
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
658
        const void *ibuf[6]= {buftmp};
659
        void *obuf[6]= {audio_out2};
660
        int istride[6]= {isize};
661
        int ostride[6]= {osize};
662
        int len= size_out/istride[0];
663
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
664
            printf("av_audio_convert() failed\n");
665
            if (exit_on_error)
666
                av_exit(1);
667
            return;
668
        }
669
        buftmp = audio_out2;
670
        size_out = len*osize;
671
    }
672

    
673
    /* now encode as many frames as possible */
674
    if (enc->frame_size > 1) {
675
        /* output resampled raw samples */
676
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
677
            fprintf(stderr, "av_fifo_realloc2() failed\n");
678
            av_exit(1);
679
        }
680
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
681

    
682
        frame_bytes = enc->frame_size * osize * enc->channels;
683

    
684
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
685
            AVPacket pkt;
686
            av_init_packet(&pkt);
687

    
688
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
689

    
690
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
691

    
692
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
693
                                       (short *)audio_buf);
694
            if (ret < 0) {
695
                fprintf(stderr, "Audio encoding failed\n");
696
                av_exit(1);
697
            }
698
            audio_size += ret;
699
            pkt.stream_index= ost->index;
700
            pkt.data= audio_out;
701
            pkt.size= ret;
702
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
703
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
704
            pkt.flags |= PKT_FLAG_KEY;
705
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
706

    
707
            ost->sync_opts += enc->frame_size;
708
        }
709
    } else {
710
        AVPacket pkt;
711
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
712
        av_init_packet(&pkt);
713

    
714
        ost->sync_opts += size_out / (osize * enc->channels);
715

    
716
        /* output a pcm frame */
717
        /* determine the size of the coded buffer */
718
        size_out /= osize;
719
        if (coded_bps)
720
            size_out *= coded_bps;
721

    
722
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
723
        ret = avcodec_encode_audio(enc, audio_out, size_out,
724
                                   (short *)buftmp);
725
        if (ret < 0) {
726
            fprintf(stderr, "Audio encoding failed\n");
727
            av_exit(1);
728
        }
729
        audio_size += ret;
730
        pkt.stream_index= ost->index;
731
        pkt.data= audio_out;
732
        pkt.size= ret;
733
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
734
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
735
        pkt.flags |= PKT_FLAG_KEY;
736
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
737
    }
738
}
739

    
740
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
741
{
742
    AVCodecContext *dec;
743
    AVPicture *picture2;
744
    AVPicture picture_tmp;
745
    uint8_t *buf = 0;
746

    
747
    dec = ist->st->codec;
748

    
749
    /* deinterlace : must be done before any resize */
750
    if (do_deinterlace) {
751
        int size;
752

    
753
        /* create temporary picture */
754
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
755
        buf = av_malloc(size);
756
        if (!buf)
757
            return;
758

    
759
        picture2 = &picture_tmp;
760
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
761

    
762
        if (do_deinterlace){
763
            if(avpicture_deinterlace(picture2, picture,
764
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
765
                /* if error, do not deinterlace */
766
                fprintf(stderr, "Deinterlacing failed\n");
767
                av_free(buf);
768
                buf = NULL;
769
                picture2 = picture;
770
            }
771
        } else {
772
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
773
        }
774
    } else {
775
        picture2 = picture;
776
    }
777

    
778
    if (picture != picture2)
779
        *picture = *picture2;
780
    *bufp = buf;
781
}
782

    
783
/* we begin to correct av delay at this threshold */
784
#define AV_DELAY_MAX 0.100
785

    
786
static void do_subtitle_out(AVFormatContext *s,
787
                            AVOutputStream *ost,
788
                            AVInputStream *ist,
789
                            AVSubtitle *sub,
790
                            int64_t pts)
791
{
792
    static uint8_t *subtitle_out = NULL;
793
    int subtitle_out_max_size = 65536;
794
    int subtitle_out_size, nb, i;
795
    AVCodecContext *enc;
796
    AVPacket pkt;
797

    
798
    if (pts == AV_NOPTS_VALUE) {
799
        fprintf(stderr, "Subtitle packets must have a pts\n");
800
        if (exit_on_error)
801
            av_exit(1);
802
        return;
803
    }
804

    
805
    enc = ost->st->codec;
806

    
807
    if (!subtitle_out) {
808
        subtitle_out = av_malloc(subtitle_out_max_size);
809
    }
810

    
811
    /* Note: DVB subtitle need one packet to draw them and one other
812
       packet to clear them */
813
    /* XXX: signal it in the codec context ? */
814
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
815
        nb = 2;
816
    else
817
        nb = 1;
818

    
819
    for(i = 0; i < nb; i++) {
820
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
821
                                                    subtitle_out_max_size, sub);
822

    
823
        av_init_packet(&pkt);
824
        pkt.stream_index = ost->index;
825
        pkt.data = subtitle_out;
826
        pkt.size = subtitle_out_size;
827
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
828
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
829
            /* XXX: the pts correction is handled here. Maybe handling
830
               it in the codec would be better */
831
            if (i == 0)
832
                pkt.pts += 90 * sub->start_display_time;
833
            else
834
                pkt.pts += 90 * sub->end_display_time;
835
        }
836
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
837
    }
838
}
839

    
840
static int bit_buffer_size= 1024*256;
841
static uint8_t *bit_buffer= NULL;
842

    
843
static void do_video_out(AVFormatContext *s,
844
                         AVOutputStream *ost,
845
                         AVInputStream *ist,
846
                         AVFrame *in_picture,
847
                         int *frame_size)
848
{
849
    int nb_frames, i, ret;
850
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
851
    AVFrame picture_crop_temp, picture_pad_temp;
852
    AVCodecContext *enc, *dec;
853

    
854
    avcodec_get_frame_defaults(&picture_crop_temp);
855
    avcodec_get_frame_defaults(&picture_pad_temp);
856

    
857
    enc = ost->st->codec;
858
    dec = ist->st->codec;
859

    
860
    /* by default, we output a single frame */
861
    nb_frames = 1;
862

    
863
    *frame_size = 0;
864

    
865
    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
866
        double vdelta;
867
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
868
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
869
        if (vdelta < -1.1)
870
            nb_frames = 0;
871
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
872
            if(vdelta<=-0.6){
873
                nb_frames=0;
874
            }else if(vdelta>0.6)
875
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
876
        }else if (vdelta > 1.1)
877
            nb_frames = lrintf(vdelta);
878
//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);
879
        if (nb_frames == 0){
880
            ++nb_frames_drop;
881
            if (verbose>2)
882
                fprintf(stderr, "*** drop!\n");
883
        }else if (nb_frames > 1) {
884
            nb_frames_dup += nb_frames;
885
            if (verbose>2)
886
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
887
        }
888
    }else
889
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
890

    
891
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
892
    if (nb_frames <= 0)
893
        return;
894

    
895
    if (ost->video_crop) {
896
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
897
            fprintf(stderr, "error cropping picture\n");
898
            if (exit_on_error)
899
                av_exit(1);
900
            return;
901
        }
902
        formatted_picture = &picture_crop_temp;
903
    } else {
904
        formatted_picture = in_picture;
905
    }
906

    
907
    final_picture = formatted_picture;
908
    padding_src = formatted_picture;
909
    resampling_dst = &ost->pict_tmp;
910
    if (ost->video_pad) {
911
        final_picture = &ost->pict_tmp;
912
        if (ost->video_resample) {
913
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
914
                fprintf(stderr, "error padding picture\n");
915
                if (exit_on_error)
916
                    av_exit(1);
917
                return;
918
            }
919
            resampling_dst = &picture_pad_temp;
920
        }
921
    }
922

    
923
    if (ost->video_resample) {
924
        padding_src = NULL;
925
        final_picture = &ost->pict_tmp;
926
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
927
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
928
    }
929

    
930
    if (ost->video_pad) {
931
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
932
                enc->height, enc->width, enc->pix_fmt,
933
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
934
    }
935

    
936
    /* duplicates frame if needed */
937
    for(i=0;i<nb_frames;i++) {
938
        AVPacket pkt;
939
        av_init_packet(&pkt);
940
        pkt.stream_index= ost->index;
941

    
942
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
943
            /* raw pictures are written as AVPicture structure to
944
               avoid any copies. We support temorarily the older
945
               method. */
946
            AVFrame* old_frame = enc->coded_frame;
947
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
948
            pkt.data= (uint8_t *)final_picture;
949
            pkt.size=  sizeof(AVPicture);
950
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
951
            pkt.flags |= PKT_FLAG_KEY;
952

    
953
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
954
            enc->coded_frame = old_frame;
955
        } else {
956
            AVFrame big_picture;
957

    
958
            big_picture= *final_picture;
959
            /* better than nothing: use input picture interlaced
960
               settings */
961
            big_picture.interlaced_frame = in_picture->interlaced_frame;
962
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
963
                if(top_field_first == -1)
964
                    big_picture.top_field_first = in_picture->top_field_first;
965
                else
966
                    big_picture.top_field_first = top_field_first;
967
            }
968

    
969
            /* handles sameq here. This is not correct because it may
970
               not be a global option */
971
            if (same_quality) {
972
                big_picture.quality = ist->st->quality;
973
            }else
974
                big_picture.quality = ost->st->quality;
975
            if(!me_threshold)
976
                big_picture.pict_type = 0;
977
//            big_picture.pts = AV_NOPTS_VALUE;
978
            big_picture.pts= ost->sync_opts;
979
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
980
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
981
            ret = avcodec_encode_video(enc,
982
                                       bit_buffer, bit_buffer_size,
983
                                       &big_picture);
984
            if (ret < 0) {
985
                fprintf(stderr, "Video encoding failed\n");
986
                av_exit(1);
987
            }
988
            //enc->frame_number = enc->real_pict_num;
989
            if(ret>0){
990
                pkt.data= bit_buffer;
991
                pkt.size= ret;
992
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
993
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
994
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
995
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
996
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
997

    
998
                if(enc->coded_frame->key_frame)
999
                    pkt.flags |= PKT_FLAG_KEY;
1000
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1001
                *frame_size = ret;
1002
                video_size += ret;
1003
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
1004
                //        enc->frame_number-1, enc->real_pict_num, ret,
1005
                //        enc->pict_type);
1006
                /* if two pass, output log */
1007
                if (ost->logfile && enc->stats_out) {
1008
                    fprintf(ost->logfile, "%s", enc->stats_out);
1009
                }
1010
            }
1011
        }
1012
        ost->sync_opts++;
1013
        ost->frame_number++;
1014
    }
1015
}
1016

    
1017
static double psnr(double d){
1018
    return -10.0*log(d)/log(10.0);
1019
}
1020

    
1021
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1022
                           int frame_size)
1023
{
1024
    AVCodecContext *enc;
1025
    int frame_number;
1026
    double ti1, bitrate, avg_bitrate;
1027

    
1028
    /* this is executed just the first time do_video_stats is called */
1029
    if (!vstats_file) {
1030
        vstats_file = fopen(vstats_filename, "w");
1031
        if (!vstats_file) {
1032
            perror("fopen");
1033
            av_exit(1);
1034
        }
1035
    }
1036

    
1037
    enc = ost->st->codec;
1038
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1039
        frame_number = ost->frame_number;
1040
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1041
        if (enc->flags&CODEC_FLAG_PSNR)
1042
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1043

    
1044
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1045
        /* compute pts value */
1046
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1047
        if (ti1 < 0.01)
1048
            ti1 = 0.01;
1049

    
1050
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1051
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1052
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1053
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1054
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1055
    }
1056
}
1057

    
1058
static void print_report(AVFormatContext **output_files,
1059
                         AVOutputStream **ost_table, int nb_ostreams,
1060
                         int is_last_report)
1061
{
1062
    char buf[1024];
1063
    AVOutputStream *ost;
1064
    AVFormatContext *oc;
1065
    int64_t total_size;
1066
    AVCodecContext *enc;
1067
    int frame_number, vid, i;
1068
    double bitrate, ti1, pts;
1069
    static int64_t last_time = -1;
1070
    static int qp_histogram[52];
1071

    
1072
    if (!is_last_report) {
1073
        int64_t cur_time;
1074
        /* display the report every 0.5 seconds */
1075
        cur_time = av_gettime();
1076
        if (last_time == -1) {
1077
            last_time = cur_time;
1078
            return;
1079
        }
1080
        if ((cur_time - last_time) < 500000)
1081
            return;
1082
        last_time = cur_time;
1083
    }
1084

    
1085

    
1086
    oc = output_files[0];
1087

    
1088
    total_size = url_fsize(oc->pb);
1089
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1090
        total_size= url_ftell(oc->pb);
1091

    
1092
    buf[0] = '\0';
1093
    ti1 = 1e10;
1094
    vid = 0;
1095
    for(i=0;i<nb_ostreams;i++) {
1096
        ost = ost_table[i];
1097
        enc = ost->st->codec;
1098
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1099
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1100
                     !ost->st->stream_copy ?
1101
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1102
        }
1103
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1104
            float t = (av_gettime()-timer_start) / 1000000.0;
1105

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

    
1152
    if (verbose || is_last_report) {
1153
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1154

    
1155
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1156
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1157
            (double)total_size / 1024, ti1, bitrate);
1158

    
1159
        if (verbose > 1)
1160
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1161
                  nb_frames_dup, nb_frames_drop);
1162

    
1163
        if (verbose >= 0)
1164
            fprintf(stderr, "%s    \r", buf);
1165

    
1166
        fflush(stderr);
1167
    }
1168

    
1169
    if (is_last_report && verbose >= 0){
1170
        int64_t raw= audio_size + video_size + extra_size;
1171
        fprintf(stderr, "\n");
1172
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1173
                video_size/1024.0,
1174
                audio_size/1024.0,
1175
                extra_size/1024.0,
1176
                100.0*(total_size - raw)/raw
1177
        );
1178
    }
1179
}
1180

    
1181
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1182
static int output_packet(AVInputStream *ist, int ist_index,
1183
                         AVOutputStream **ost_table, int nb_ostreams,
1184
                         const AVPacket *pkt)
1185
{
1186
    AVFormatContext *os;
1187
    AVOutputStream *ost;
1188
    int ret, i;
1189
    uint8_t *data_buf;
1190
    int data_size, got_picture;
1191
    AVFrame picture;
1192
    void *buffer_to_free;
1193
    static unsigned int samples_size= 0;
1194
    AVSubtitle subtitle, *subtitle_to_free;
1195
    int got_subtitle;
1196
    AVPacket avpkt;
1197

    
1198
    if(ist->next_pts == AV_NOPTS_VALUE)
1199
        ist->next_pts= ist->pts;
1200

    
1201
    if (pkt == NULL) {
1202
        /* EOF handling */
1203
        av_init_packet(&avpkt);
1204
        avpkt.data = NULL;
1205
        avpkt.size = 0;
1206
        goto handle_eof;
1207
    } else {
1208
        avpkt = *pkt;
1209
    }
1210

    
1211
    if(pkt->dts != AV_NOPTS_VALUE)
1212
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1213

    
1214
    //while we have more to decode or while the decoder did output something on EOF
1215
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1216
    handle_eof:
1217
        ist->pts= ist->next_pts;
1218

    
1219
        if(avpkt.size && avpkt.size != pkt->size && verbose>0)
1220
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1221

    
1222
        /* decode the packet if needed */
1223
        data_buf = NULL; /* fail safe */
1224
        data_size = 0;
1225
        subtitle_to_free = NULL;
1226
        if (ist->decoding_needed) {
1227
            switch(ist->st->codec->codec_type) {
1228
            case CODEC_TYPE_AUDIO:{
1229
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1230
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1231
                    av_free(samples);
1232
                    samples= av_malloc(samples_size);
1233
                }
1234
                data_size= samples_size;
1235
                    /* XXX: could avoid copy if PCM 16 bits with same
1236
                       endianness as CPU */
1237
                ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size,
1238
                                            &avpkt);
1239
                if (ret < 0)
1240
                    goto fail_decode;
1241
                avpkt.data += ret;
1242
                avpkt.size -= ret;
1243
                /* Some bug in mpeg audio decoder gives */
1244
                /* data_size < 0, it seems they are overflows */
1245
                if (data_size <= 0) {
1246
                    /* no audio frame */
1247
                    continue;
1248
                }
1249
                data_buf = (uint8_t *)samples;
1250
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1251
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1252
                break;}
1253
            case CODEC_TYPE_VIDEO:
1254
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1255
                    /* XXX: allocate picture correctly */
1256
                    avcodec_get_frame_defaults(&picture);
1257

    
1258
                    ret = avcodec_decode_video2(ist->st->codec,
1259
                                                &picture, &got_picture, &avpkt);
1260
                    ist->st->quality= picture.quality;
1261
                    if (ret < 0)
1262
                        goto fail_decode;
1263
                    if (!got_picture) {
1264
                        /* no picture yet */
1265
                        goto discard_packet;
1266
                    }
1267
                    if (ist->st->codec->time_base.num != 0) {
1268
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1269
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1270
                                          ist->st->codec->time_base.num * ticks) /
1271
                            ist->st->codec->time_base.den;
1272
                    }
1273
                    avpkt.size = 0;
1274
                    break;
1275
            case CODEC_TYPE_SUBTITLE:
1276
                ret = avcodec_decode_subtitle2(ist->st->codec,
1277
                                               &subtitle, &got_subtitle, &avpkt);
1278
                if (ret < 0)
1279
                    goto fail_decode;
1280
                if (!got_subtitle) {
1281
                    goto discard_packet;
1282
                }
1283
                subtitle_to_free = &subtitle;
1284
                avpkt.size = 0;
1285
                break;
1286
            default:
1287
                goto fail_decode;
1288
            }
1289
        } else {
1290
            switch(ist->st->codec->codec_type) {
1291
            case CODEC_TYPE_AUDIO:
1292
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1293
                    ist->st->codec->sample_rate;
1294
                break;
1295
            case CODEC_TYPE_VIDEO:
1296
                if (ist->st->codec->time_base.num != 0) {
1297
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1298
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1299
                                      ist->st->codec->time_base.num * ticks) /
1300
                        ist->st->codec->time_base.den;
1301
                }
1302
                break;
1303
            }
1304
            data_buf = avpkt.data;
1305
            data_size = avpkt.size;
1306
            ret = avpkt.size;
1307
            avpkt.size = 0;
1308
        }
1309

    
1310
        buffer_to_free = NULL;
1311
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1312
            pre_process_video_frame(ist, (AVPicture *)&picture,
1313
                                    &buffer_to_free);
1314
        }
1315

    
1316
        // preprocess audio (volume)
1317
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1318
            if (audio_volume != 256) {
1319
                short *volp;
1320
                volp = samples;
1321
                for(i=0;i<(data_size / sizeof(short));i++) {
1322
                    int v = ((*volp) * audio_volume + 128) >> 8;
1323
                    if (v < -32768) v = -32768;
1324
                    if (v >  32767) v = 32767;
1325
                    *volp++ = v;
1326
                }
1327
            }
1328
        }
1329

    
1330
        /* frame rate emulation */
1331
        if (rate_emu) {
1332
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1333
            int64_t now = av_gettime() - ist->start;
1334
            if (pts > now)
1335
                usleep(pts - now);
1336
        }
1337

    
1338
        /* if output time reached then transcode raw format,
1339
           encode packets and output them */
1340
        if (start_time == 0 || ist->pts >= start_time)
1341
            for(i=0;i<nb_ostreams;i++) {
1342
                int frame_size;
1343

    
1344
                ost = ost_table[i];
1345
                if (ost->source_index == ist_index) {
1346
                    os = output_files[ost->file_index];
1347

    
1348
#if 0
1349
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1350
                           (double)pkt->pts / AV_TIME_BASE,
1351
                           ((double)ist->pts / AV_TIME_BASE) -
1352
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1353
#endif
1354
                    /* set the input output pts pairs */
1355
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1356

    
1357
                    if (ost->encoding_needed) {
1358
                        switch(ost->st->codec->codec_type) {
1359
                        case CODEC_TYPE_AUDIO:
1360
                            do_audio_out(os, ost, ist, data_buf, data_size);
1361
                            break;
1362
                        case CODEC_TYPE_VIDEO:
1363
                            do_video_out(os, ost, ist, &picture, &frame_size);
1364
                            if (vstats_filename && frame_size)
1365
                                do_video_stats(os, ost, frame_size);
1366
                            break;
1367
                        case CODEC_TYPE_SUBTITLE:
1368
                            do_subtitle_out(os, ost, ist, &subtitle,
1369
                                            pkt->pts);
1370
                            break;
1371
                        default:
1372
                            abort();
1373
                        }
1374
                    } else {
1375
                        AVFrame avframe; //FIXME/XXX remove this
1376
                        AVPacket opkt;
1377
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1378

    
1379
                        av_init_packet(&opkt);
1380

    
1381
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1382
                            continue;
1383

    
1384
                        /* no reencoding needed : output the packet directly */
1385
                        /* force the input stream PTS */
1386

    
1387
                        avcodec_get_frame_defaults(&avframe);
1388
                        ost->st->codec->coded_frame= &avframe;
1389
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1390

    
1391
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1392
                            audio_size += data_size;
1393
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1394
                            video_size += data_size;
1395
                            ost->sync_opts++;
1396
                        }
1397

    
1398
                        opkt.stream_index= ost->index;
1399
                        if(pkt->pts != AV_NOPTS_VALUE)
1400
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1401
                        else
1402
                            opkt.pts= AV_NOPTS_VALUE;
1403

    
1404
                        if (pkt->dts == AV_NOPTS_VALUE)
1405
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1406
                        else
1407
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1408
                        opkt.dts -= ost_tb_start_time;
1409

    
1410
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1411
                        opkt.flags= pkt->flags;
1412

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

    
1417
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1418
                        ost->st->codec->frame_number++;
1419
                        ost->frame_number++;
1420
                        av_free_packet(&opkt);
1421
                    }
1422
                }
1423
            }
1424
        av_free(buffer_to_free);
1425
        /* XXX: allocate the subtitles in the codec ? */
1426
        if (subtitle_to_free) {
1427
            if (subtitle_to_free->rects != NULL) {
1428
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1429
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1430
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1431
                    av_freep(&subtitle_to_free->rects[i]);
1432
                }
1433
                av_freep(&subtitle_to_free->rects);
1434
            }
1435
            subtitle_to_free->num_rects = 0;
1436
            subtitle_to_free = NULL;
1437
        }
1438
    }
1439
 discard_packet:
1440
    if (pkt == NULL) {
1441
        /* EOF handling */
1442

    
1443
        for(i=0;i<nb_ostreams;i++) {
1444
            ost = ost_table[i];
1445
            if (ost->source_index == ist_index) {
1446
                AVCodecContext *enc= ost->st->codec;
1447
                os = output_files[ost->file_index];
1448

    
1449
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1450
                    continue;
1451
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1452
                    continue;
1453

    
1454
                if (ost->encoding_needed) {
1455
                    for(;;) {
1456
                        AVPacket pkt;
1457
                        int fifo_bytes;
1458
                        av_init_packet(&pkt);
1459
                        pkt.stream_index= ost->index;
1460

    
1461
                        switch(ost->st->codec->codec_type) {
1462
                        case CODEC_TYPE_AUDIO:
1463
                            fifo_bytes = av_fifo_size(ost->fifo);
1464
                            ret = 0;
1465
                            /* encode any samples remaining in fifo */
1466
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1467
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1468
                                int fs_tmp = enc->frame_size;
1469
                                enc->frame_size = fifo_bytes / (osize * enc->channels);
1470
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1471
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1472
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1473
                                                          ost->st->time_base.num, enc->sample_rate);
1474
                                enc->frame_size = fs_tmp;
1475
                            }
1476
                            if(ret <= 0) {
1477
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1478
                            }
1479
                            if (ret < 0) {
1480
                                fprintf(stderr, "Audio encoding failed\n");
1481
                                av_exit(1);
1482
                            }
1483
                            audio_size += ret;
1484
                            pkt.flags |= PKT_FLAG_KEY;
1485
                            break;
1486
                        case CODEC_TYPE_VIDEO:
1487
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1488
                            if (ret < 0) {
1489
                                fprintf(stderr, "Video encoding failed\n");
1490
                                av_exit(1);
1491
                            }
1492
                            video_size += ret;
1493
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1494
                                pkt.flags |= PKT_FLAG_KEY;
1495
                            if (ost->logfile && enc->stats_out) {
1496
                                fprintf(ost->logfile, "%s", enc->stats_out);
1497
                            }
1498
                            break;
1499
                        default:
1500
                            ret=-1;
1501
                        }
1502

    
1503
                        if(ret<=0)
1504
                            break;
1505
                        pkt.data= bit_buffer;
1506
                        pkt.size= ret;
1507
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1508
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1509
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1510
                    }
1511
                }
1512
            }
1513
        }
1514
    }
1515

    
1516
    return 0;
1517
 fail_decode:
1518
    return -1;
1519
}
1520

    
1521
static void print_sdp(AVFormatContext **avc, int n)
1522
{
1523
    char sdp[2048];
1524

    
1525
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1526
    printf("SDP:\n%s\n", sdp);
1527
    fflush(stdout);
1528
}
1529

    
1530
static int stream_index_from_inputs(AVFormatContext **input_files,
1531
                                    int nb_input_files,
1532
                                    AVInputFile *file_table,
1533
                                    AVInputStream **ist_table,
1534
                                    enum CodecType type,
1535
                                    int programid)
1536
{
1537
    int p, q, z;
1538
    for(z=0; z<nb_input_files; z++) {
1539
        AVFormatContext *ic = input_files[z];
1540
        for(p=0; p<ic->nb_programs; p++) {
1541
            AVProgram *program = ic->programs[p];
1542
            if(program->id != programid)
1543
                continue;
1544
            for(q=0; q<program->nb_stream_indexes; q++) {
1545
                int sidx = program->stream_index[q];
1546
                int ris = file_table[z].ist_index + sidx;
1547
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1548
                    return ris;
1549
            }
1550
        }
1551
    }
1552

    
1553
    return -1;
1554
}
1555

    
1556
/*
1557
 * The following code is the main loop of the file converter
1558
 */
1559
static int av_encode(AVFormatContext **output_files,
1560
                     int nb_output_files,
1561
                     AVFormatContext **input_files,
1562
                     int nb_input_files,
1563
                     AVStreamMap *stream_maps, int nb_stream_maps)
1564
{
1565
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1566
    AVFormatContext *is, *os;
1567
    AVCodecContext *codec, *icodec;
1568
    AVOutputStream *ost, **ost_table = NULL;
1569
    AVInputStream *ist, **ist_table = NULL;
1570
    AVInputFile *file_table;
1571
    char error[1024];
1572
    int key;
1573
    int want_sdp = 1;
1574
    uint8_t no_packet[MAX_FILES]={0};
1575
    int no_packet_count=0;
1576

    
1577
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1578
    if (!file_table)
1579
        goto fail;
1580

    
1581
    /* input stream init */
1582
    j = 0;
1583
    for(i=0;i<nb_input_files;i++) {
1584
        is = input_files[i];
1585
        file_table[i].ist_index = j;
1586
        file_table[i].nb_streams = is->nb_streams;
1587
        j += is->nb_streams;
1588
    }
1589
    nb_istreams = j;
1590

    
1591
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1592
    if (!ist_table)
1593
        goto fail;
1594

    
1595
    for(i=0;i<nb_istreams;i++) {
1596
        ist = av_mallocz(sizeof(AVInputStream));
1597
        if (!ist)
1598
            goto fail;
1599
        ist_table[i] = ist;
1600
    }
1601
    j = 0;
1602
    for(i=0;i<nb_input_files;i++) {
1603
        is = input_files[i];
1604
        for(k=0;k<is->nb_streams;k++) {
1605
            ist = ist_table[j++];
1606
            ist->st = is->streams[k];
1607
            ist->file_index = i;
1608
            ist->index = k;
1609
            ist->discard = 1; /* the stream is discarded by default
1610
                                 (changed later) */
1611

    
1612
            if (rate_emu) {
1613
                ist->start = av_gettime();
1614
            }
1615
        }
1616
    }
1617

    
1618
    /* output stream init */
1619
    nb_ostreams = 0;
1620
    for(i=0;i<nb_output_files;i++) {
1621
        os = output_files[i];
1622
        if (!os->nb_streams) {
1623
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1624
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1625
            av_exit(1);
1626
        }
1627
        nb_ostreams += os->nb_streams;
1628
    }
1629
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1630
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1631
        av_exit(1);
1632
    }
1633

    
1634
    /* Sanity check the mapping args -- do the input files & streams exist? */
1635
    for(i=0;i<nb_stream_maps;i++) {
1636
        int fi = stream_maps[i].file_index;
1637
        int si = stream_maps[i].stream_index;
1638

    
1639
        if (fi < 0 || fi > nb_input_files - 1 ||
1640
            si < 0 || si > file_table[fi].nb_streams - 1) {
1641
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1642
            av_exit(1);
1643
        }
1644
        fi = stream_maps[i].sync_file_index;
1645
        si = stream_maps[i].sync_stream_index;
1646
        if (fi < 0 || fi > nb_input_files - 1 ||
1647
            si < 0 || si > file_table[fi].nb_streams - 1) {
1648
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1649
            av_exit(1);
1650
        }
1651
    }
1652

    
1653
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1654
    if (!ost_table)
1655
        goto fail;
1656
    for(i=0;i<nb_ostreams;i++) {
1657
        ost = av_mallocz(sizeof(AVOutputStream));
1658
        if (!ost)
1659
            goto fail;
1660
        ost_table[i] = ost;
1661
    }
1662

    
1663
    n = 0;
1664
    for(k=0;k<nb_output_files;k++) {
1665
        os = output_files[k];
1666
        for(i=0;i<os->nb_streams;i++,n++) {
1667
            int found;
1668
            ost = ost_table[n];
1669
            ost->file_index = k;
1670
            ost->index = i;
1671
            ost->st = os->streams[i];
1672
            if (nb_stream_maps > 0) {
1673
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1674
                    stream_maps[n].stream_index;
1675

    
1676
                /* Sanity check that the stream types match */
1677
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1678
                    int i= ost->file_index;
1679
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1680
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1681
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1682
                        ost->file_index, ost->index);
1683
                    av_exit(1);
1684
                }
1685

    
1686
            } else {
1687
                if(opt_programid) {
1688
                    found = 0;
1689
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1690
                    if(j != -1) {
1691
                        ost->source_index = j;
1692
                        found = 1;
1693
                    }
1694
                } else {
1695
                    /* get corresponding input stream index : we select the first one with the right type */
1696
                    found = 0;
1697
                    for(j=0;j<nb_istreams;j++) {
1698
                        ist = ist_table[j];
1699
                        if (ist->discard &&
1700
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1701
                            ost->source_index = j;
1702
                            found = 1;
1703
                            break;
1704
                        }
1705
                    }
1706
                }
1707

    
1708
                if (!found) {
1709
                    if(! opt_programid) {
1710
                        /* try again and reuse existing stream */
1711
                        for(j=0;j<nb_istreams;j++) {
1712
                            ist = ist_table[j];
1713
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1714
                                ost->source_index = j;
1715
                                found = 1;
1716
                            }
1717
                        }
1718
                    }
1719
                    if (!found) {
1720
                        int i= ost->file_index;
1721
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1722
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1723
                                ost->file_index, ost->index);
1724
                        av_exit(1);
1725
                    }
1726
                }
1727
            }
1728
            ist = ist_table[ost->source_index];
1729
            ist->discard = 0;
1730
            ost->sync_ist = (nb_stream_maps > 0) ?
1731
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1732
                         stream_maps[n].sync_stream_index] : ist;
1733
        }
1734
    }
1735

    
1736
    /* for each output stream, we compute the right encoding parameters */
1737
    for(i=0;i<nb_ostreams;i++) {
1738
        AVMetadataTag *lang;
1739
        ost = ost_table[i];
1740
        os = output_files[ost->file_index];
1741
        ist = ist_table[ost->source_index];
1742

    
1743
        codec = ost->st->codec;
1744
        icodec = ist->st->codec;
1745

    
1746
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1747
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1748
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1749

    
1750
        ost->st->disposition = ist->st->disposition;
1751

    
1752
        if (ost->st->stream_copy) {
1753
            /* if stream_copy is selected, no need to decode or encode */
1754
            codec->codec_id = icodec->codec_id;
1755
            codec->codec_type = icodec->codec_type;
1756

    
1757
            if(!codec->codec_tag){
1758
                if(   !os->oformat->codec_tag
1759
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1760
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1761
                    codec->codec_tag = icodec->codec_tag;
1762
            }
1763

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

    
1880
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1881
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1882
                         i);
1883
                if (codec->flags & CODEC_FLAG_PASS1) {
1884
                    f = fopen(logfilename, "w");
1885
                    if (!f) {
1886
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1887
                        av_exit(1);
1888
                    }
1889
                    ost->logfile = f;
1890
                } else {
1891
                    /* read the log file */
1892
                    f = fopen(logfilename, "r");
1893
                    if (!f) {
1894
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1895
                        av_exit(1);
1896
                    }
1897
                    fseek(f, 0, SEEK_END);
1898
                    size = ftell(f);
1899
                    fseek(f, 0, SEEK_SET);
1900
                    logbuffer = av_malloc(size + 1);
1901
                    if (!logbuffer) {
1902
                        fprintf(stderr, "Could not allocate log buffer\n");
1903
                        av_exit(1);
1904
                    }
1905
                    size = fread(logbuffer, 1, size, f);
1906
                    fclose(f);
1907
                    logbuffer[size] = '\0';
1908
                    codec->stats_in = logbuffer;
1909
                }
1910
            }
1911
        }
1912
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1913
            int size= codec->width * codec->height;
1914
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1915
        }
1916
    }
1917

    
1918
    if (!bit_buffer)
1919
        bit_buffer = av_malloc(bit_buffer_size);
1920
    if (!bit_buffer) {
1921
        ret = AVERROR(ENOMEM);
1922
        goto fail;
1923
    }
1924

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

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

    
1972
    /* init pts */
1973
    for(i=0;i<nb_istreams;i++) {
1974
        ist = ist_table[i];
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
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
1990
                     out_file_index, out_file_index, in_file_index);
1991
            ret = AVERROR(EINVAL);
1992
            goto dump_format;
1993
        }
1994
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1995
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
1996
                     in_file_index, out_file_index, in_file_index);
1997
            ret = AVERROR(EINVAL);
1998
            goto dump_format;
1999
        }
2000

    
2001
        out_file = output_files[out_file_index];
2002
        in_file = input_files[in_file_index];
2003

    
2004

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

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

    
2025
 dump_format:
2026
    /* dump the file output parameters - cannot be done before in case
2027
       of stream copy */
2028
    for(i=0;i<nb_output_files;i++) {
2029
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2030
    }
2031

    
2032
    /* dump the stream mapping */
2033
    if (verbose >= 0) {
2034
        fprintf(stderr, "Stream mapping:\n");
2035
        for(i=0;i<nb_ostreams;i++) {
2036
            ost = ost_table[i];
2037
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2038
                    ist_table[ost->source_index]->file_index,
2039
                    ist_table[ost->source_index]->index,
2040
                    ost->file_index,
2041
                    ost->index);
2042
            if (ost->sync_ist != ist_table[ost->source_index])
2043
                fprintf(stderr, " [sync #%d.%d]",
2044
                        ost->sync_ist->file_index,
2045
                        ost->sync_ist->index);
2046
            fprintf(stderr, "\n");
2047
        }
2048
    }
2049

    
2050
    if (ret) {
2051
        fprintf(stderr, "%s\n", error);
2052
        goto fail;
2053
    }
2054

    
2055
    if (want_sdp) {
2056
        print_sdp(output_files, nb_output_files);
2057
    }
2058

    
2059
    if (!using_stdin && verbose >= 0) {
2060
        fprintf(stderr, "Press [q] to stop encoding\n");
2061
        url_set_interrupt_cb(decode_interrupt_cb);
2062
    }
2063
    term_init();
2064

    
2065
    timer_start = av_gettime();
2066

    
2067
    for(; received_sigterm == 0;) {
2068
        int file_index, ist_index;
2069
        AVPacket pkt;
2070
        double ipts_min;
2071
        double opts_min;
2072

    
2073
    redo:
2074
        ipts_min= 1e100;
2075
        opts_min= 1e100;
2076
        /* if 'q' pressed, exits */
2077
        if (!using_stdin) {
2078
            if (q_pressed)
2079
                break;
2080
            /* read_key() returns 0 on EOF */
2081
            key = read_key();
2082
            if (key == 'q')
2083
                break;
2084
        }
2085

    
2086
        /* select the stream that we must read now by looking at the
2087
           smallest output pts */
2088
        file_index = -1;
2089
        for(i=0;i<nb_ostreams;i++) {
2090
            double ipts, opts;
2091
            ost = ost_table[i];
2092
            os = output_files[ost->file_index];
2093
            ist = ist_table[ost->source_index];
2094
            if(no_packet[ist->file_index])
2095
                continue;
2096
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2097
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2098
            else
2099
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2100
            ipts = (double)ist->pts;
2101
            if (!file_table[ist->file_index].eof_reached){
2102
                if(ipts < ipts_min) {
2103
                    ipts_min = ipts;
2104
                    if(input_sync ) file_index = ist->file_index;
2105
                }
2106
                if(opts < opts_min) {
2107
                    opts_min = opts;
2108
                    if(!input_sync) file_index = ist->file_index;
2109
                }
2110
            }
2111
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2112
                file_index= -1;
2113
                break;
2114
            }
2115
        }
2116
        /* if none, if is finished */
2117
        if (file_index < 0) {
2118
            if(no_packet_count){
2119
                no_packet_count=0;
2120
                memset(no_packet, 0, sizeof(no_packet));
2121
                usleep(10000);
2122
                continue;
2123
            }
2124
            break;
2125
        }
2126

    
2127
        /* finish if recording time exhausted */
2128
        if (opts_min >= (recording_time / 1000000.0))
2129
            break;
2130

    
2131
        /* finish if limit size exhausted */
2132
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2133
            break;
2134

    
2135
        /* read a frame from it and output it in the fifo */
2136
        is = input_files[file_index];
2137
        ret= av_read_frame(is, &pkt);
2138
        if(ret == AVERROR(EAGAIN)){
2139
            no_packet[file_index]=1;
2140
            no_packet_count++;
2141
            continue;
2142
        }
2143
        if (ret < 0) {
2144
            file_table[file_index].eof_reached = 1;
2145
            if (opt_shortest)
2146
                break;
2147
            else
2148
                continue;
2149
        }
2150

    
2151
        no_packet_count=0;
2152
        memset(no_packet, 0, sizeof(no_packet));
2153

    
2154
        if (do_pkt_dump) {
2155
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2156
        }
2157
        /* the following test is needed in case new streams appear
2158
           dynamically in stream : we ignore them */
2159
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2160
            goto discard_packet;
2161
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2162
        ist = ist_table[ist_index];
2163
        if (ist->discard)
2164
            goto discard_packet;
2165

    
2166
        if (pkt.dts != AV_NOPTS_VALUE)
2167
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2168
        if (pkt.pts != AV_NOPTS_VALUE)
2169
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2170

    
2171
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2172
            if(pkt.pts != AV_NOPTS_VALUE)
2173
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2174
            if(pkt.dts != AV_NOPTS_VALUE)
2175
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2176
        }
2177

    
2178
//        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);
2179
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2180
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2181
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2182
            int64_t delta= pkt_dts - ist->next_pts;
2183
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2184
                input_files_ts_offset[ist->file_index]-= delta;
2185
                if (verbose > 2)
2186
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2187
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2188
                if(pkt.pts != AV_NOPTS_VALUE)
2189
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2190
            }
2191
        }
2192

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

    
2196
            if (verbose >= 0)
2197
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2198
                        ist->file_index, ist->index);
2199
            if (exit_on_error)
2200
                av_exit(1);
2201
            av_free_packet(&pkt);
2202
            goto redo;
2203
        }
2204

    
2205
    discard_packet:
2206
        av_free_packet(&pkt);
2207

    
2208
        /* dump report by using the output first video and audio streams */
2209
        print_report(output_files, ost_table, nb_ostreams, 0);
2210
    }
2211

    
2212
    /* at the end of stream, we must flush the decoder buffers */
2213
    for(i=0;i<nb_istreams;i++) {
2214
        ist = ist_table[i];
2215
        if (ist->decoding_needed) {
2216
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2217
        }
2218
    }
2219

    
2220
    term_exit();
2221

    
2222
    /* write the trailer if needed and close file */
2223
    for(i=0;i<nb_output_files;i++) {
2224
        os = output_files[i];
2225
        av_write_trailer(os);
2226
    }
2227

    
2228
    /* dump report by using the first video and audio streams */
2229
    print_report(output_files, ost_table, nb_ostreams, 1);
2230

    
2231
    /* close each encoder */
2232
    for(i=0;i<nb_ostreams;i++) {
2233
        ost = ost_table[i];
2234
        if (ost->encoding_needed) {
2235
            av_freep(&ost->st->codec->stats_in);
2236
            avcodec_close(ost->st->codec);
2237
        }
2238
    }
2239

    
2240
    /* close each decoder */
2241
    for(i=0;i<nb_istreams;i++) {
2242
        ist = ist_table[i];
2243
        if (ist->decoding_needed) {
2244
            avcodec_close(ist->st->codec);
2245
        }
2246
    }
2247

    
2248
    /* finished ! */
2249
    ret = 0;
2250

    
2251
 fail:
2252
    av_freep(&bit_buffer);
2253
    av_free(file_table);
2254

    
2255
    if (ist_table) {
2256
        for(i=0;i<nb_istreams;i++) {
2257
            ist = ist_table[i];
2258
            av_free(ist);
2259
        }
2260
        av_free(ist_table);
2261
    }
2262
    if (ost_table) {
2263
        for(i=0;i<nb_ostreams;i++) {
2264
            ost = ost_table[i];
2265
            if (ost) {
2266
                if (ost->logfile) {
2267
                    fclose(ost->logfile);
2268
                    ost->logfile = NULL;
2269
                }
2270
                av_fifo_free(ost->fifo); /* works even if fifo is not
2271
                                             initialized but set to zero */
2272
                av_free(ost->pict_tmp.data[0]);
2273
                if (ost->video_resample)
2274
                    sws_freeContext(ost->img_resample_ctx);
2275
                if (ost->resample)
2276
                    audio_resample_close(ost->resample);
2277
                if (ost->reformat_ctx)
2278
                    av_audio_convert_free(ost->reformat_ctx);
2279
                av_free(ost);
2280
            }
2281
        }
2282
        av_free(ost_table);
2283
    }
2284
    return ret;
2285
}
2286

    
2287
#if 0
2288
int file_read(const char *filename)
2289
{
2290
    URLContext *h;
2291
    unsigned char buffer[1024];
2292
    int len, i;
2293

2294
    if (url_open(&h, filename, O_RDONLY) < 0) {
2295
        printf("could not open '%s'\n", filename);
2296
        return -1;
2297
    }
2298
    for(;;) {
2299
        len = url_read(h, buffer, sizeof(buffer));
2300
        if (len <= 0)
2301
            break;
2302
        for(i=0;i<len;i++) putchar(buffer[i]);
2303
    }
2304
    url_close(h);
2305
    return 0;
2306
}
2307
#endif
2308

    
2309
static void opt_format(const char *arg)
2310
{
2311
    /* compatibility stuff for pgmyuv */
2312
    if (!strcmp(arg, "pgmyuv")) {
2313
        pgmyuv_compatibility_hack=1;
2314
//        opt_image_format(arg);
2315
        arg = "image2";
2316
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2317
    }
2318

    
2319
    file_iformat = av_find_input_format(arg);
2320
    file_oformat = guess_format(arg, NULL, NULL);
2321
    if (!file_iformat && !file_oformat) {
2322
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2323
        av_exit(1);
2324
    }
2325
}
2326

    
2327
static void opt_video_rc_override_string(const char *arg)
2328
{
2329
    video_rc_override_string = arg;
2330
}
2331

    
2332
static int opt_me_threshold(const char *opt, const char *arg)
2333
{
2334
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2335
    return 0;
2336
}
2337

    
2338
static void opt_loglevel(const char *opt, const char *arg)
2339
{
2340
    int level = parse_number_or_die(opt, arg, OPT_INT, INT_MIN, INT_MAX);
2341
    av_log_set_level(level);
2342
}
2343

    
2344
static int opt_verbose(const char *opt, const char *arg)
2345
{
2346
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2347
    return 0;
2348
}
2349

    
2350
static int opt_frame_rate(const char *opt, const char *arg)
2351
{
2352
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2353
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2354
        av_exit(1);
2355
    }
2356
    return 0;
2357
}
2358

    
2359
static int opt_bitrate(const char *opt, const char *arg)
2360
{
2361
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2362

    
2363
    opt_default(opt, arg);
2364

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

    
2368
    return 0;
2369
}
2370

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

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

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

    
2425
static void opt_frame_crop_right(const char *arg)
2426
{
2427
    frame_rightBand = atoi(arg);
2428
    if (frame_rightBand < 0) {
2429
        fprintf(stderr, "Incorrect right crop size\n");
2430
        av_exit(1);
2431
    }
2432
    if ((frame_rightBand % 2) != 0) {
2433
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2434
        av_exit(1);
2435
    }
2436
    if ((frame_rightBand) >= frame_width){
2437
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2438
        av_exit(1);
2439
    }
2440
    frame_width -= frame_rightBand;
2441
}
2442

    
2443
static void opt_frame_size(const char *arg)
2444
{
2445
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2446
        fprintf(stderr, "Incorrect frame size\n");
2447
        av_exit(1);
2448
    }
2449
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2450
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2451
        av_exit(1);
2452
    }
2453
}
2454

    
2455

    
2456
#define SCALEBITS 10
2457
#define ONE_HALF  (1 << (SCALEBITS - 1))
2458
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2459

    
2460
#define RGB_TO_Y(r, g, b) \
2461
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2462
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2463

    
2464
#define RGB_TO_U(r1, g1, b1, shift)\
2465
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2466
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2467

    
2468
#define RGB_TO_V(r1, g1, b1, shift)\
2469
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2470
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2471

    
2472
static void opt_pad_color(const char *arg) {
2473
    /* Input is expected to be six hex digits similar to
2474
       how colors are expressed in html tags (but without the #) */
2475
    int rgb = strtol(arg, NULL, 16);
2476
    int r,g,b;
2477

    
2478
    r = (rgb >> 16);
2479
    g = ((rgb >> 8) & 255);
2480
    b = (rgb & 255);
2481

    
2482
    padcolor[0] = RGB_TO_Y(r,g,b);
2483
    padcolor[1] = RGB_TO_U(r,g,b,0);
2484
    padcolor[2] = RGB_TO_V(r,g,b,0);
2485
}
2486

    
2487
static void opt_frame_pad_top(const char *arg)
2488
{
2489
    frame_padtop = atoi(arg);
2490
    if (frame_padtop < 0) {
2491
        fprintf(stderr, "Incorrect top pad size\n");
2492
        av_exit(1);
2493
    }
2494
    if ((frame_padtop % 2) != 0) {
2495
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2496
        av_exit(1);
2497
    }
2498
}
2499

    
2500
static void opt_frame_pad_bottom(const char *arg)
2501
{
2502
    frame_padbottom = atoi(arg);
2503
    if (frame_padbottom < 0) {
2504
        fprintf(stderr, "Incorrect bottom pad size\n");
2505
        av_exit(1);
2506
    }
2507
    if ((frame_padbottom % 2) != 0) {
2508
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2509
        av_exit(1);
2510
    }
2511
}
2512

    
2513

    
2514
static void opt_frame_pad_left(const char *arg)
2515
{
2516
    frame_padleft = atoi(arg);
2517
    if (frame_padleft < 0) {
2518
        fprintf(stderr, "Incorrect left pad size\n");
2519
        av_exit(1);
2520
    }
2521
    if ((frame_padleft % 2) != 0) {
2522
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2523
        av_exit(1);
2524
    }
2525
}
2526

    
2527

    
2528
static void opt_frame_pad_right(const char *arg)
2529
{
2530
    frame_padright = atoi(arg);
2531
    if (frame_padright < 0) {
2532
        fprintf(stderr, "Incorrect right pad size\n");
2533
        av_exit(1);
2534
    }
2535
    if ((frame_padright % 2) != 0) {
2536
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2537
        av_exit(1);
2538
    }
2539
}
2540

    
2541
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2542
{
2543
    int i;
2544
    char fmt_str[128];
2545
    for (i=-1; i < nb_fmts; i++) {
2546
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2547
        fprintf(stdout, "%s\n", fmt_str);
2548
    }
2549
}
2550

    
2551
static void opt_frame_pix_fmt(const char *arg)
2552
{
2553
    if (strcmp(arg, "list")) {
2554
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2555
        if (frame_pix_fmt == PIX_FMT_NONE) {
2556
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2557
            av_exit(1);
2558
        }
2559
    } else {
2560
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2561
        av_exit(0);
2562
    }
2563
}
2564

    
2565
static void opt_frame_aspect_ratio(const char *arg)
2566
{
2567
    int x = 0, y = 0;
2568
    double ar = 0;
2569
    const char *p;
2570
    char *end;
2571

    
2572
    p = strchr(arg, ':');
2573
    if (p) {
2574
        x = strtol(arg, &end, 10);
2575
        if (end == p)
2576
            y = strtol(end+1, &end, 10);
2577
        if (x > 0 && y > 0)
2578
            ar = (double)x / (double)y;
2579
    } else
2580
        ar = strtod(arg, NULL);
2581

    
2582
    if (!ar) {
2583
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2584
        av_exit(1);
2585
    }
2586
    frame_aspect_ratio = ar;
2587
}
2588

    
2589
static int opt_metadata(const char *opt, const char *arg)
2590
{
2591
    char *mid= strchr(arg, '=');
2592

    
2593
    if(!mid){
2594
        fprintf(stderr, "Missing =\n");
2595
        av_exit(1);
2596
    }
2597
    *mid++= 0;
2598

    
2599
    metadata_count++;
2600
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2601
    metadata[metadata_count-1].key  = av_strdup(arg);
2602
    metadata[metadata_count-1].value= av_strdup(mid);
2603

    
2604
    return 0;
2605
}
2606

    
2607
static void opt_qscale(const char *arg)
2608
{
2609
    video_qscale = atof(arg);
2610
    if (video_qscale <= 0 ||
2611
        video_qscale > 255) {
2612
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2613
        av_exit(1);
2614
    }
2615
}
2616

    
2617
static void opt_top_field_first(const char *arg)
2618
{
2619
    top_field_first= atoi(arg);
2620
}
2621

    
2622
static int opt_thread_count(const char *opt, const char *arg)
2623
{
2624
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2625
#if !HAVE_THREADS
2626
    if (verbose >= 0)
2627
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2628
#endif
2629
    return 0;
2630
}
2631

    
2632
static void opt_audio_sample_fmt(const char *arg)
2633
{
2634
    if (strcmp(arg, "list"))
2635
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2636
    else {
2637
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2638
        av_exit(0);
2639
    }
2640
}
2641

    
2642
static int opt_audio_rate(const char *opt, const char *arg)
2643
{
2644
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2645
    return 0;
2646
}
2647

    
2648
static int opt_audio_channels(const char *opt, const char *arg)
2649
{
2650
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2651
    return 0;
2652
}
2653

    
2654
static void opt_video_channel(const char *arg)
2655
{
2656
    video_channel = strtol(arg, NULL, 0);
2657
}
2658

    
2659
static void opt_video_standard(const char *arg)
2660
{
2661
    video_standard = av_strdup(arg);
2662
}
2663

    
2664
static void opt_codec(int *pstream_copy, char **pcodec_name,
2665
                      int codec_type, const char *arg)
2666
{
2667
    av_freep(pcodec_name);
2668
    if (!strcmp(arg, "copy")) {
2669
        *pstream_copy = 1;
2670
    } else {
2671
        *pcodec_name = av_strdup(arg);
2672
    }
2673
}
2674

    
2675
static void opt_audio_codec(const char *arg)
2676
{
2677
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2678
}
2679

    
2680
static void opt_audio_tag(const char *arg)
2681
{
2682
    char *tail;
2683
    audio_codec_tag= strtol(arg, &tail, 0);
2684

    
2685
    if(!tail || *tail)
2686
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2687
}
2688

    
2689
static void opt_video_tag(const char *arg)
2690
{
2691
    char *tail;
2692
    video_codec_tag= strtol(arg, &tail, 0);
2693

    
2694
    if(!tail || *tail)
2695
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2696
}
2697

    
2698
static void opt_video_codec(const char *arg)
2699
{
2700
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2701
}
2702

    
2703
static void opt_subtitle_codec(const char *arg)
2704
{
2705
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2706
}
2707

    
2708
static void opt_subtitle_tag(const char *arg)
2709
{
2710
    char *tail;
2711
    subtitle_codec_tag= strtol(arg, &tail, 0);
2712

    
2713
    if(!tail || *tail)
2714
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2715
}
2716

    
2717
static void opt_map(const char *arg)
2718
{
2719
    AVStreamMap *m;
2720
    char *p;
2721

    
2722
    m = &stream_maps[nb_stream_maps++];
2723

    
2724
    m->file_index = strtol(arg, &p, 0);
2725
    if (*p)
2726
        p++;
2727

    
2728
    m->stream_index = strtol(p, &p, 0);
2729
    if (*p) {
2730
        p++;
2731
        m->sync_file_index = strtol(p, &p, 0);
2732
        if (*p)
2733
            p++;
2734
        m->sync_stream_index = strtol(p, &p, 0);
2735
    } else {
2736
        m->sync_file_index = m->file_index;
2737
        m->sync_stream_index = m->stream_index;
2738
    }
2739
}
2740

    
2741
static void opt_map_meta_data(const char *arg)
2742
{
2743
    AVMetaDataMap *m;
2744
    char *p;
2745

    
2746
    m = &meta_data_maps[nb_meta_data_maps++];
2747

    
2748
    m->out_file = strtol(arg, &p, 0);
2749
    if (*p)
2750
        p++;
2751

    
2752
    m->in_file = strtol(p, &p, 0);
2753
}
2754

    
2755
static void opt_input_ts_scale(const char *arg)
2756
{
2757
    unsigned int stream;
2758
    double scale;
2759
    char *p;
2760

    
2761
    stream = strtol(arg, &p, 0);
2762
    if (*p)
2763
        p++;
2764
    scale= strtod(p, &p);
2765

    
2766
    if(stream >= MAX_STREAMS)
2767
        av_exit(1);
2768

    
2769
    input_files_ts_scale[nb_input_files][stream]= scale;
2770
}
2771

    
2772
static int opt_recording_time(const char *opt, const char *arg)
2773
{
2774
    recording_time = parse_time_or_die(opt, arg, 1);
2775
    return 0;
2776
}
2777

    
2778
static int opt_start_time(const char *opt, const char *arg)
2779
{
2780
    start_time = parse_time_or_die(opt, arg, 1);
2781
    return 0;
2782
}
2783

    
2784
static int opt_rec_timestamp(const char *opt, const char *arg)
2785
{
2786
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2787
    return 0;
2788
}
2789

    
2790
static int opt_input_ts_offset(const char *opt, const char *arg)
2791
{
2792
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2793
    return 0;
2794
}
2795

    
2796
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2797
{
2798
    const char *codec_string = encoder ? "encoder" : "decoder";
2799
    AVCodec *codec;
2800

    
2801
    if(!name)
2802
        return CODEC_ID_NONE;
2803
    codec = encoder ?
2804
        avcodec_find_encoder_by_name(name) :
2805
        avcodec_find_decoder_by_name(name);
2806
    if(!codec) {
2807
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2808
        av_exit(1);
2809
    }
2810
    if(codec->type != type) {
2811
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2812
        av_exit(1);
2813
    }
2814
    return codec->id;
2815
}
2816

    
2817
static void opt_input_file(const char *filename)
2818
{
2819
    AVFormatContext *ic;
2820
    AVFormatParameters params, *ap = &params;
2821
    int err, i, ret, rfps, rfps_base;
2822
    int64_t timestamp;
2823

    
2824
    if (!strcmp(filename, "-"))
2825
        filename = "pipe:";
2826

    
2827
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2828
                    !strcmp(filename, "/dev/stdin");
2829

    
2830
    /* get default parameters from command line */
2831
    ic = avformat_alloc_context();
2832

    
2833
    memset(ap, 0, sizeof(*ap));
2834
    ap->prealloced_context = 1;
2835
    ap->sample_rate = audio_sample_rate;
2836
    ap->channels = audio_channels;
2837
    ap->time_base.den = frame_rate.num;
2838
    ap->time_base.num = frame_rate.den;
2839
    ap->width = frame_width + frame_padleft + frame_padright;
2840
    ap->height = frame_height + frame_padtop + frame_padbottom;
2841
    ap->pix_fmt = frame_pix_fmt;
2842
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2843
    ap->channel = video_channel;
2844
    ap->standard = video_standard;
2845
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2846
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2847
    if(pgmyuv_compatibility_hack)
2848
        ap->video_codec_id= CODEC_ID_PGMYUV;
2849

    
2850
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2851

    
2852
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2853
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2854
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2855
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2856

    
2857
    /* open the input file with generic libav function */
2858
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2859
    if (err < 0) {
2860
        print_error(filename, err);
2861
        av_exit(1);
2862
    }
2863
    if(opt_programid) {
2864
        int i;
2865
        for(i=0; i<ic->nb_programs; i++)
2866
            if(ic->programs[i]->id != opt_programid)
2867
                ic->programs[i]->discard = AVDISCARD_ALL;
2868
    }
2869

    
2870
    ic->loop_input = loop_input;
2871

    
2872
    /* If not enough info to get the stream parameters, we decode the
2873
       first frames to get it. (used in mpeg case for example) */
2874
    ret = av_find_stream_info(ic);
2875
    if (ret < 0 && verbose >= 0) {
2876
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2877
        av_exit(1);
2878
    }
2879

    
2880
    timestamp = start_time;
2881
    /* add the stream start time */
2882
    if (ic->start_time != AV_NOPTS_VALUE)
2883
        timestamp += ic->start_time;
2884

    
2885
    /* if seeking requested, we execute it */
2886
    if (start_time != 0) {
2887
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2888
        if (ret < 0) {
2889
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2890
                    filename, (double)timestamp / AV_TIME_BASE);
2891
        }
2892
        /* reset seek info */
2893
        start_time = 0;
2894
    }
2895

    
2896
    /* update the current parameters so that they match the one of the input stream */
2897
    for(i=0;i<ic->nb_streams;i++) {
2898
        AVCodecContext *enc = ic->streams[i]->codec;
2899
        if(thread_count>1)
2900
            avcodec_thread_init(enc, thread_count);
2901
        enc->thread_count= thread_count;
2902
        switch(enc->codec_type) {
2903
        case CODEC_TYPE_AUDIO:
2904
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2905
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2906
            channel_layout = enc->channel_layout;
2907
            audio_channels = enc->channels;
2908
            audio_sample_rate = enc->sample_rate;
2909
            audio_sample_fmt = enc->sample_fmt;
2910
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2911
            if(audio_disable)
2912
                ic->streams[i]->discard= AVDISCARD_ALL;
2913
            break;
2914
        case CODEC_TYPE_VIDEO:
2915
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2916
            frame_height = enc->height;
2917
            frame_width = enc->width;
2918
            if(ic->streams[i]->sample_aspect_ratio.num)
2919
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2920
            else
2921
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2922
            frame_aspect_ratio *= (float) enc->width / enc->height;
2923
            frame_pix_fmt = enc->pix_fmt;
2924
            rfps      = ic->streams[i]->r_frame_rate.num;
2925
            rfps_base = ic->streams[i]->r_frame_rate.den;
2926
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2927
            if(me_threshold)
2928
                enc->debug |= FF_DEBUG_MV;
2929

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

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

    
2936
                    (float)rfps / rfps_base, rfps, rfps_base);
2937
            }
2938
            /* update the current frame rate to match the stream frame rate */
2939
            frame_rate.num = rfps;
2940
            frame_rate.den = rfps_base;
2941

    
2942
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2943
            if(video_disable)
2944
                ic->streams[i]->discard= AVDISCARD_ALL;
2945
            else if(video_discard)
2946
                ic->streams[i]->discard= video_discard;
2947
            break;
2948
        case CODEC_TYPE_DATA:
2949
            break;
2950
        case CODEC_TYPE_SUBTITLE:
2951
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2952
            if(subtitle_disable)
2953
                ic->streams[i]->discard = AVDISCARD_ALL;
2954
            break;
2955
        case CODEC_TYPE_ATTACHMENT:
2956
        case CODEC_TYPE_UNKNOWN:
2957
            nb_icodecs++;
2958
            break;
2959
        default:
2960
            abort();
2961
        }
2962
    }
2963

    
2964
    input_files[nb_input_files] = ic;
2965
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2966
    /* dump the file content */
2967
    if (verbose >= 0)
2968
        dump_format(ic, nb_input_files, filename, 0);
2969

    
2970
    nb_input_files++;
2971
    file_iformat = NULL;
2972
    file_oformat = NULL;
2973

    
2974
    video_channel = 0;
2975

    
2976
    av_freep(&video_codec_name);
2977
    av_freep(&audio_codec_name);
2978
    av_freep(&subtitle_codec_name);
2979
}
2980

    
2981
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2982
                                         int *has_subtitle_ptr)
2983
{
2984
    int has_video, has_audio, has_subtitle, i, j;
2985
    AVFormatContext *ic;
2986

    
2987
    has_video = 0;
2988
    has_audio = 0;
2989
    has_subtitle = 0;
2990
    for(j=0;j<nb_input_files;j++) {
2991
        ic = input_files[j];
2992
        for(i=0;i<ic->nb_streams;i++) {
2993
            AVCodecContext *enc = ic->streams[i]->codec;
2994
            switch(enc->codec_type) {
2995
            case CODEC_TYPE_AUDIO:
2996
                has_audio = 1;
2997
                break;
2998
            case CODEC_TYPE_VIDEO:
2999
                has_video = 1;
3000
                break;
3001
            case CODEC_TYPE_SUBTITLE:
3002
                has_subtitle = 1;
3003
                break;
3004
            case CODEC_TYPE_DATA:
3005
            case CODEC_TYPE_ATTACHMENT:
3006
            case CODEC_TYPE_UNKNOWN:
3007
                break;
3008
            default:
3009
                abort();
3010
            }
3011
        }
3012
    }
3013
    *has_video_ptr = has_video;
3014
    *has_audio_ptr = has_audio;
3015
    *has_subtitle_ptr = has_subtitle;
3016
}
3017

    
3018
static void new_video_stream(AVFormatContext *oc)
3019
{
3020
    AVStream *st;
3021
    AVCodecContext *video_enc;
3022
    int codec_id;
3023

    
3024
    st = av_new_stream(oc, oc->nb_streams);
3025
    if (!st) {
3026
        fprintf(stderr, "Could not alloc stream\n");
3027
        av_exit(1);
3028
    }
3029
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3030
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3031
    video_bitstream_filters= NULL;
3032

    
3033
    if(thread_count>1)
3034
        avcodec_thread_init(st->codec, thread_count);
3035

    
3036
    video_enc = st->codec;
3037

    
3038
    if(video_codec_tag)
3039
        video_enc->codec_tag= video_codec_tag;
3040

    
3041
    if(   (video_global_header&1)
3042
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3043
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3044
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3045
    }
3046
    if(video_global_header&2){
3047
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3048
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3049
    }
3050

    
3051
    if (video_stream_copy) {
3052
        st->stream_copy = 1;
3053
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3054
        video_enc->sample_aspect_ratio =
3055
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3056
    } else {
3057
        const char *p;
3058
        int i;
3059
        AVCodec *codec;
3060
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3061

    
3062
        if (video_codec_name) {
3063
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3064
            codec = avcodec_find_encoder_by_name(video_codec_name);
3065
            output_codecs[nb_ocodecs] = codec;
3066
        } else {
3067
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3068
            codec = avcodec_find_encoder(codec_id);
3069
        }
3070

    
3071
        video_enc->codec_id = codec_id;
3072

    
3073
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3074

    
3075
        if (codec && codec->supported_framerates && !force_fps)
3076
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3077
        video_enc->time_base.den = fps.num;
3078
        video_enc->time_base.num = fps.den;
3079

    
3080
        video_enc->width = frame_width + frame_padright + frame_padleft;
3081
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3082
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3083
        video_enc->pix_fmt = frame_pix_fmt;
3084
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3085

    
3086
        if(codec && codec->pix_fmts){
3087
            const enum PixelFormat *p= codec->pix_fmts;
3088
            for(; *p!=-1; p++){
3089
                if(*p == video_enc->pix_fmt)
3090
                    break;
3091
            }
3092
            if(*p == -1)
3093
                video_enc->pix_fmt = codec->pix_fmts[0];
3094
        }
3095

    
3096
        if (intra_only)
3097
            video_enc->gop_size = 0;
3098
        if (video_qscale || same_quality) {
3099
            video_enc->flags |= CODEC_FLAG_QSCALE;
3100
            video_enc->global_quality=
3101
                st->quality = FF_QP2LAMBDA * video_qscale;
3102
        }
3103

    
3104
        if(intra_matrix)
3105
            video_enc->intra_matrix = intra_matrix;
3106
        if(inter_matrix)
3107
            video_enc->inter_matrix = inter_matrix;
3108

    
3109
        video_enc->thread_count = thread_count;
3110
        p= video_rc_override_string;
3111
        for(i=0; p; i++){
3112
            int start, end, q;
3113
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3114
            if(e!=3){
3115
                fprintf(stderr, "error parsing rc_override\n");
3116
                av_exit(1);
3117
            }
3118
            video_enc->rc_override=
3119
                av_realloc(video_enc->rc_override,
3120
                           sizeof(RcOverride)*(i+1));
3121
            video_enc->rc_override[i].start_frame= start;
3122
            video_enc->rc_override[i].end_frame  = end;
3123
            if(q>0){
3124
                video_enc->rc_override[i].qscale= q;
3125
                video_enc->rc_override[i].quality_factor= 1.0;
3126
            }
3127
            else{
3128
                video_enc->rc_override[i].qscale= 0;
3129
                video_enc->rc_override[i].quality_factor= -q/100.0;
3130
            }
3131
            p= strchr(p, '/');
3132
            if(p) p++;
3133
        }
3134
        video_enc->rc_override_count=i;
3135
        if (!video_enc->rc_initial_buffer_occupancy)
3136
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3137
        video_enc->me_threshold= me_threshold;
3138
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3139

    
3140
        if (do_psnr)
3141
            video_enc->flags|= CODEC_FLAG_PSNR;
3142

    
3143
        /* two pass mode */
3144
        if (do_pass) {
3145
            if (do_pass == 1) {
3146
                video_enc->flags |= CODEC_FLAG_PASS1;
3147
            } else {
3148
                video_enc->flags |= CODEC_FLAG_PASS2;
3149
            }
3150
        }
3151
    }
3152
    nb_ocodecs++;
3153

    
3154
    /* reset some key parameters */
3155
    video_disable = 0;
3156
    av_freep(&video_codec_name);
3157
    video_stream_copy = 0;
3158
}
3159

    
3160
static void new_audio_stream(AVFormatContext *oc)
3161
{
3162
    AVStream *st;
3163
    AVCodecContext *audio_enc;
3164
    int codec_id;
3165

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

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

    
3176
    if(thread_count>1)
3177
        avcodec_thread_init(st->codec, thread_count);
3178

    
3179
    audio_enc = st->codec;
3180
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3181

    
3182
    if(audio_codec_tag)
3183
        audio_enc->codec_tag= audio_codec_tag;
3184

    
3185
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3186
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3187
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3188
    }
3189
    if (audio_stream_copy) {
3190
        st->stream_copy = 1;
3191
        audio_enc->channels = audio_channels;
3192
    } else {
3193
        AVCodec *codec;
3194

    
3195
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3196

    
3197
        if (audio_codec_name) {
3198
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3199
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3200
            output_codecs[nb_ocodecs] = codec;
3201
        } else {
3202
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3203
            codec = avcodec_find_encoder(codec_id);
3204
        }
3205
        audio_enc->codec_id = codec_id;
3206

    
3207
        if (audio_qscale > QSCALE_NONE) {
3208
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3209
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3210
        }
3211
        audio_enc->thread_count = thread_count;
3212
        audio_enc->channels = audio_channels;
3213
        audio_enc->sample_fmt = audio_sample_fmt;
3214
        audio_enc->channel_layout = channel_layout;
3215

    
3216
        if(codec && codec->sample_fmts){
3217
            const enum SampleFormat *p= codec->sample_fmts;
3218
            for(; *p!=-1; p++){
3219
                if(*p == audio_enc->sample_fmt)
3220
                    break;
3221
            }
3222
            if(*p == -1)
3223
                audio_enc->sample_fmt = codec->sample_fmts[0];
3224
        }
3225
    }
3226
    nb_ocodecs++;
3227
    audio_enc->sample_rate = audio_sample_rate;
3228
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3229
    if (audio_language) {
3230
        av_metadata_set(&st->metadata, "language", audio_language);
3231
        av_free(audio_language);
3232
        audio_language = NULL;
3233
    }
3234

    
3235
    /* reset some key parameters */
3236
    audio_disable = 0;
3237
    av_freep(&audio_codec_name);
3238
    audio_stream_copy = 0;
3239
}
3240

    
3241
static void new_subtitle_stream(AVFormatContext *oc)
3242
{
3243
    AVStream *st;
3244
    AVCodecContext *subtitle_enc;
3245

    
3246
    st = av_new_stream(oc, oc->nb_streams);
3247
    if (!st) {
3248
        fprintf(stderr, "Could not alloc stream\n");
3249
        av_exit(1);
3250
    }
3251
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3252

    
3253
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3254
    subtitle_bitstream_filters= NULL;
3255

    
3256
    subtitle_enc = st->codec;
3257
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3258

    
3259
    if(subtitle_codec_tag)
3260
        subtitle_enc->codec_tag= subtitle_codec_tag;
3261

    
3262
    if (subtitle_stream_copy) {
3263
        st->stream_copy = 1;
3264
    } else {
3265
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3266
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3267
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3268
    }
3269
    nb_ocodecs++;
3270

    
3271
    if (subtitle_language) {
3272
        av_metadata_set(&st->metadata, "language", subtitle_language);
3273
        av_free(subtitle_language);
3274
        subtitle_language = NULL;
3275
    }
3276

    
3277
    subtitle_disable = 0;
3278
    av_freep(&subtitle_codec_name);
3279
    subtitle_stream_copy = 0;
3280
}
3281

    
3282
static void opt_new_audio_stream(void)
3283
{
3284
    AVFormatContext *oc;
3285
    if (nb_output_files <= 0) {
3286
        fprintf(stderr, "At least one output file must be specified\n");
3287
        av_exit(1);
3288
    }
3289
    oc = output_files[nb_output_files - 1];
3290
    new_audio_stream(oc);
3291
}
3292

    
3293
static void opt_new_video_stream(void)
3294
{
3295
    AVFormatContext *oc;
3296
    if (nb_output_files <= 0) {
3297
        fprintf(stderr, "At least one output file must be specified\n");
3298
        av_exit(1);
3299
    }
3300
    oc = output_files[nb_output_files - 1];
3301
    new_video_stream(oc);
3302
}
3303

    
3304
static void opt_new_subtitle_stream(void)
3305
{
3306
    AVFormatContext *oc;
3307
    if (nb_output_files <= 0) {
3308
        fprintf(stderr, "At least one output file must be specified\n");
3309
        av_exit(1);
3310
    }
3311
    oc = output_files[nb_output_files - 1];
3312
    new_subtitle_stream(oc);
3313
}
3314

    
3315
static void opt_output_file(const char *filename)
3316
{
3317
    AVFormatContext *oc;
3318
    int use_video, use_audio, use_subtitle;
3319
    int input_has_video, input_has_audio, input_has_subtitle;
3320
    AVFormatParameters params, *ap = &params;
3321

    
3322
    if (!strcmp(filename, "-"))
3323
        filename = "pipe:";
3324

    
3325
    oc = avformat_alloc_context();
3326

    
3327
    if (!file_oformat) {
3328
        file_oformat = guess_format(NULL, filename, NULL);
3329
        if (!file_oformat) {
3330
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3331
                    filename);
3332
            av_exit(1);
3333
        }
3334
    }
3335

    
3336
    oc->oformat = file_oformat;
3337
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3338

    
3339
    if (!strcmp(file_oformat->name, "ffm") &&
3340
        av_strstart(filename, "http:", NULL)) {
3341
        /* special case for files sent to ffserver: we get the stream
3342
           parameters from ffserver */
3343
        int err = read_ffserver_streams(oc, filename);
3344
        if (err < 0) {
3345
            print_error(filename, err);
3346
            av_exit(1);
3347
        }
3348
    } else {
3349
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3350
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3351
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3352

    
3353
        /* disable if no corresponding type found and at least one
3354
           input file */
3355
        if (nb_input_files > 0) {
3356
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3357
                                         &input_has_subtitle);
3358
            if (!input_has_video)
3359
                use_video = 0;
3360
            if (!input_has_audio)
3361
                use_audio = 0;
3362
            if (!input_has_subtitle)
3363
                use_subtitle = 0;
3364
        }
3365

    
3366
        /* manual disable */
3367
        if (audio_disable) {
3368
            use_audio = 0;
3369
        }
3370
        if (video_disable) {
3371
            use_video = 0;
3372
        }
3373
        if (subtitle_disable) {
3374
            use_subtitle = 0;
3375
        }
3376

    
3377
        if (use_video) {
3378
            new_video_stream(oc);
3379
        }
3380

    
3381
        if (use_audio) {
3382
            new_audio_stream(oc);
3383
        }
3384

    
3385
        if (use_subtitle) {
3386
            new_subtitle_stream(oc);
3387
        }
3388

    
3389
        oc->timestamp = rec_timestamp;
3390

    
3391
        for(; metadata_count>0; metadata_count--){
3392
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3393
                                           metadata[metadata_count-1].value);
3394
        }
3395
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3396
    }
3397

    
3398
    output_files[nb_output_files++] = oc;
3399

    
3400
    /* check filename in case of an image number is expected */
3401
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3402
        if (!av_filename_number_test(oc->filename)) {
3403
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3404
            av_exit(1);
3405
        }
3406
    }
3407

    
3408
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3409
        /* test if it already exists to avoid loosing precious files */
3410
        if (!file_overwrite &&
3411
            (strchr(filename, ':') == NULL ||
3412
             filename[1] == ':' ||
3413
             av_strstart(filename, "file:", NULL))) {
3414
            if (url_exist(filename)) {
3415
                if (!using_stdin) {
3416
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3417
                    fflush(stderr);
3418
                    if (!read_yesno()) {
3419
                        fprintf(stderr, "Not overwriting - exiting\n");
3420
                        av_exit(1);
3421
                    }
3422
                }
3423
                else {
3424
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3425
                    av_exit(1);
3426
                }
3427
            }
3428
        }
3429

    
3430
        /* open the file */
3431
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3432
            fprintf(stderr, "Could not open '%s'\n", filename);
3433
            av_exit(1);
3434
        }
3435
    }
3436

    
3437
    memset(ap, 0, sizeof(*ap));
3438
    if (av_set_parameters(oc, ap) < 0) {
3439
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3440
                oc->filename);
3441
        av_exit(1);
3442
    }
3443

    
3444
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3445
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3446
    oc->loop_output = loop_output;
3447
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3448

    
3449
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3450

    
3451
    /* reset some options */
3452
    file_oformat = NULL;
3453
    file_iformat = NULL;
3454
}
3455

    
3456
/* same option as mencoder */
3457
static void opt_pass(const char *pass_str)
3458
{
3459
    int pass;
3460
    pass = atoi(pass_str);
3461
    if (pass != 1 && pass != 2) {
3462
        fprintf(stderr, "pass number can be only 1 or 2\n");
3463
        av_exit(1);
3464
    }
3465
    do_pass = pass;
3466
}
3467

    
3468
static int64_t getutime(void)
3469
{
3470
#if HAVE_GETRUSAGE
3471
    struct rusage rusage;
3472

    
3473
    getrusage(RUSAGE_SELF, &rusage);
3474
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3475
#elif HAVE_GETPROCESSTIMES
3476
    HANDLE proc;
3477
    FILETIME c, e, k, u;
3478
    proc = GetCurrentProcess();
3479
    GetProcessTimes(proc, &c, &e, &k, &u);
3480
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3481
#else
3482
    return av_gettime();
3483
#endif
3484
}
3485

    
3486
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3487
{
3488
    int i;
3489
    const char *p = str;
3490
    for(i = 0;; i++) {
3491
        dest[i] = atoi(p);
3492
        if(i == 63)
3493
            break;
3494
        p = strchr(p, ',');
3495
        if(!p) {
3496
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3497
            av_exit(1);
3498
        }
3499
        p++;
3500
    }
3501
}
3502

    
3503
static void opt_inter_matrix(const char *arg)
3504
{
3505
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3506
    parse_matrix_coeffs(inter_matrix, arg);
3507
}
3508

    
3509
static void opt_intra_matrix(const char *arg)
3510
{
3511
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3512
    parse_matrix_coeffs(intra_matrix, arg);
3513
}
3514

    
3515
/**
3516
 * Trivial log callback.
3517
 * Only suitable for show_help and similar since it lacks prefix handling.
3518
 */
3519
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3520
{
3521
    vfprintf(stdout, fmt, vl);
3522
}
3523

    
3524
static void show_help(void)
3525
{
3526
    av_log_set_callback(log_callback_help);
3527
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3528
           "Hyper fast Audio and Video encoder\n");
3529
    printf("\n");
3530
    show_help_options(options, "Main options:\n",
3531
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3532
    show_help_options(options, "\nAdvanced options:\n",
3533
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3534
                      OPT_EXPERT);
3535
    show_help_options(options, "\nVideo options:\n",
3536
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3537
                      OPT_VIDEO);
3538
    show_help_options(options, "\nAdvanced Video options:\n",
3539
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3540
                      OPT_VIDEO | OPT_EXPERT);
3541
    show_help_options(options, "\nAudio options:\n",
3542
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3543
                      OPT_AUDIO);
3544
    show_help_options(options, "\nAdvanced Audio options:\n",
3545
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3546
                      OPT_AUDIO | OPT_EXPERT);
3547
    show_help_options(options, "\nSubtitle options:\n",
3548
                      OPT_SUBTITLE | OPT_GRAB,
3549
                      OPT_SUBTITLE);
3550
    show_help_options(options, "\nAudio/Video grab options:\n",
3551
                      OPT_GRAB,
3552
                      OPT_GRAB);
3553
    printf("\n");
3554
    av_opt_show(avcodec_opts[0], NULL);
3555
    printf("\n");
3556
    av_opt_show(avformat_opts, NULL);
3557
    printf("\n");
3558
    av_opt_show(sws_opts, NULL);
3559
}
3560

    
3561
static void opt_target(const char *arg)
3562
{
3563
    int norm = -1;
3564
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3565

    
3566
    if(!strncmp(arg, "pal-", 4)) {
3567
        norm = 0;
3568
        arg += 4;
3569
    } else if(!strncmp(arg, "ntsc-", 5)) {
3570
        norm = 1;
3571
        arg += 5;
3572
    } else if(!strncmp(arg, "film-", 5)) {
3573
        norm = 2;
3574
        arg += 5;
3575
    } else {
3576
        int fr;
3577
        /* Calculate FR via float to avoid int overflow */
3578
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3579
        if(fr == 25000) {
3580
            norm = 0;
3581
        } else if((fr == 29970) || (fr == 23976)) {
3582
            norm = 1;
3583
        } else {
3584
            /* Try to determine PAL/NTSC by peeking in the input files */
3585
            if(nb_input_files) {
3586
                int i, j;
3587
                for(j = 0; j < nb_input_files; j++) {
3588
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3589
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3590
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3591
                            continue;
3592
                        fr = c->time_base.den * 1000 / c->time_base.num;
3593
                        if(fr == 25000) {
3594
                            norm = 0;
3595
                            break;
3596
                        } else if((fr == 29970) || (fr == 23976)) {
3597
                            norm = 1;
3598
                            break;
3599
                        }
3600
                    }
3601
                    if(norm >= 0)
3602
                        break;
3603
                }
3604
            }
3605
        }
3606
        if(verbose && norm >= 0)
3607
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3608
    }
3609

    
3610
    if(norm < 0) {
3611
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3612
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3613
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3614
        av_exit(1);
3615
    }
3616

    
3617
    if(!strcmp(arg, "vcd")) {
3618

    
3619
        opt_video_codec("mpeg1video");
3620
        opt_audio_codec("mp2");
3621
        opt_format("vcd");
3622

    
3623
        opt_frame_size(norm ? "352x240" : "352x288");
3624
        opt_frame_rate(NULL, frame_rates[norm]);
3625
        opt_default("gop", norm ? "18" : "15");
3626

    
3627
        opt_default("b", "1150000");
3628
        opt_default("maxrate", "1150000");
3629
        opt_default("minrate", "1150000");
3630
        opt_default("bufsize", "327680"); // 40*1024*8;
3631

    
3632
        opt_default("ab", "224000");
3633
        audio_sample_rate = 44100;
3634
        audio_channels = 2;
3635

    
3636
        opt_default("packetsize", "2324");
3637
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3638

    
3639
        /* We have to offset the PTS, so that it is consistent with the SCR.
3640
           SCR starts at 36000, but the first two packs contain only padding
3641
           and the first pack from the other stream, respectively, may also have
3642
           been written before.
3643
           So the real data starts at SCR 36000+3*1200. */
3644
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3645
    } else if(!strcmp(arg, "svcd")) {
3646

    
3647
        opt_video_codec("mpeg2video");
3648
        opt_audio_codec("mp2");
3649
        opt_format("svcd");
3650

    
3651
        opt_frame_size(norm ? "480x480" : "480x576");
3652
        opt_frame_rate(NULL, frame_rates[norm]);
3653
        opt_default("gop", norm ? "18" : "15");
3654

    
3655
        opt_default("b", "2040000");
3656
        opt_default("maxrate", "2516000");
3657
        opt_default("minrate", "0"); //1145000;
3658
        opt_default("bufsize", "1835008"); //224*1024*8;
3659
        opt_default("flags", "+scan_offset");
3660

    
3661

    
3662
        opt_default("ab", "224000");
3663
        audio_sample_rate = 44100;
3664

    
3665
        opt_default("packetsize", "2324");
3666

    
3667
    } else if(!strcmp(arg, "dvd")) {
3668

    
3669
        opt_video_codec("mpeg2video");
3670
        opt_audio_codec("ac3");
3671
        opt_format("dvd");
3672

    
3673
        opt_frame_size(norm ? "720x480" : "720x576");
3674
        opt_frame_rate(NULL, frame_rates[norm]);
3675
        opt_default("gop", norm ? "18" : "15");
3676

    
3677
        opt_default("b", "6000000");
3678
        opt_default("maxrate", "9000000");
3679
        opt_default("minrate", "0"); //1500000;
3680
        opt_default("bufsize", "1835008"); //224*1024*8;
3681

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

    
3685
        opt_default("ab", "448000");
3686
        audio_sample_rate = 48000;
3687

    
3688
    } else if(!strncmp(arg, "dv", 2)) {
3689

    
3690
        opt_format("dv");
3691

    
3692
        opt_frame_size(norm ? "720x480" : "720x576");
3693
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3694
                                             (norm ? "yuv411p" : "yuv420p"));
3695
        opt_frame_rate(NULL, frame_rates[norm]);
3696

    
3697
        audio_sample_rate = 48000;
3698
        audio_channels = 2;
3699

    
3700
    } else {
3701
        fprintf(stderr, "Unknown target: %s\n", arg);
3702
        av_exit(1);
3703
    }
3704
}
3705

    
3706
static void opt_vstats_file (const char *arg)
3707
{
3708
    av_free (vstats_filename);
3709
    vstats_filename=av_strdup (arg);
3710
}
3711

    
3712
static void opt_vstats (void)
3713
{
3714
    char filename[40];
3715
    time_t today2 = time(NULL);
3716
    struct tm *today = localtime(&today2);
3717

    
3718
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3719
             today->tm_sec);
3720
    opt_vstats_file(filename);
3721
}
3722

    
3723
static int opt_bsf(const char *opt, const char *arg)
3724
{
3725
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3726
    AVBitStreamFilterContext **bsfp;
3727

    
3728
    if(!bsfc){
3729
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3730
        av_exit(1);
3731
    }
3732

    
3733
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3734
          *opt == 'a' ? &audio_bitstream_filters :
3735
                        &subtitle_bitstream_filters;
3736
    while(*bsfp)
3737
        bsfp= &(*bsfp)->next;
3738

    
3739
    *bsfp= bsfc;
3740

    
3741
    return 0;
3742
}
3743

    
3744
static int opt_preset(const char *opt, const char *arg)
3745
{
3746
    FILE *f=NULL;
3747
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3748
    int i;
3749
    const char *base[2]= { getenv("HOME"),
3750
                           FFMPEG_DATADIR,
3751
                         };
3752

    
3753
    for(i=!base[0]; i<2 && !f; i++){
3754
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3755
        f= fopen(filename, "r");
3756
        if(!f){
3757
            char *codec_name= *opt == 'v' ? video_codec_name :
3758
                              *opt == 'a' ? audio_codec_name :
3759
                                            subtitle_codec_name;
3760
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3761
            f= fopen(filename, "r");
3762
        }
3763
    }
3764
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3765
              is_dos_path(arg))){
3766
        av_strlcpy(filename, arg, sizeof(filename));
3767
        f= fopen(filename, "r");
3768
    }
3769

    
3770
    if(!f){
3771
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3772
        av_exit(1);
3773
    }
3774

    
3775
    while(!feof(f)){
3776
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3777
        if(line[0] == '#' && !e)
3778
            continue;
3779
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3780
        if(e){
3781
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3782
            av_exit(1);
3783
        }
3784
        if(!strcmp(tmp, "acodec")){
3785
            opt_audio_codec(tmp2);
3786
        }else if(!strcmp(tmp, "vcodec")){
3787
            opt_video_codec(tmp2);
3788
        }else if(!strcmp(tmp, "scodec")){
3789
            opt_subtitle_codec(tmp2);
3790
        }else if(opt_default(tmp, tmp2) < 0){
3791
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3792
            av_exit(1);
3793
        }
3794
    }
3795

    
3796
    fclose(f);
3797

    
3798
    return 0;
3799
}
3800

    
3801
static const OptionDef options[] = {
3802
    /* main options */
3803
    { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3804
    { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3805
    { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3806
    { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3807
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3808
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3809
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3810
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3811
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3812
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3813
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3814
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3815
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3816
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3817
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3818
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)&opt_metadata}, "add metadata", "string=string" },
3819
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3820
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3821
      "add timings for benchmarking" },
3822
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3823
      "dump each input packet" },
3824
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3825
      "when dumping packets, also dump the payload" },
3826
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3827
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3828
    { "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)", "" },
3829
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3830
    { "loglevel", HAS_ARG | OPT_FUNC2, {(void*)opt_loglevel}, "set libav* logging level", "number" },
3831
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3832
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3833
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3834
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3835
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3836
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3837
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3838
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3839
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3840
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3841
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3842
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3843

    
3844
    /* video options */
3845
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3846
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3847
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3848
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3849
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3850
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3851
    { "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" },
3852
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3853
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3854
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3855
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3856
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3857
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3858
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3859
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3860
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3861
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3862
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3863
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3864
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3865
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3866
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3867
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3868
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3869
      "use same video quality as source (implies VBR)" },
3870
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3871
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3872
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3873
      "deinterlace pictures" },
3874
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3875
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3876
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3877
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3878
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3879
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3880
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3881
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3882
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3883
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3884
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3885

    
3886
    /* audio options */
3887
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3888
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3889
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3890
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3891
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3892
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3893
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3894
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3895
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3896
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3897
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3898
    { "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" },
3899

    
3900
    /* subtitle options */
3901
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3902
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3903
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3904
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3905
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3906

    
3907
    /* grab options */
3908
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3909
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3910
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3911

    
3912
    /* muxer options */
3913
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3914
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3915

    
3916
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3917
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3918
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3919

    
3920
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3921
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3922
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3923

    
3924
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3925
    { NULL, },
3926
};
3927

    
3928
int main(int argc, char **argv)
3929
{
3930
    int i;
3931
    int64_t ti;
3932

    
3933
    avcodec_register_all();
3934
    avdevice_register_all();
3935
    av_register_all();
3936

    
3937
    if(isatty(STDIN_FILENO))
3938
        url_set_interrupt_cb(decode_interrupt_cb);
3939

    
3940
    for(i=0; i<CODEC_TYPE_NB; i++){
3941
        avcodec_opts[i]= avcodec_alloc_context2(i);
3942
    }
3943
    avformat_opts = avformat_alloc_context();
3944
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3945

    
3946
    show_banner();
3947

    
3948
    /* parse options */
3949
    parse_options(argc, argv, options, opt_output_file);
3950

    
3951
    /* file converter / grab */
3952
    if (nb_output_files <= 0) {
3953
        fprintf(stderr, "At least one output file must be specified\n");
3954
        av_exit(1);
3955
    }
3956

    
3957
    if (nb_input_files == 0) {
3958
        fprintf(stderr, "At least one input file must be specified\n");
3959
        av_exit(1);
3960
    }
3961

    
3962
    ti = getutime();
3963
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3964
                  stream_maps, nb_stream_maps) < 0)
3965
        av_exit(1);
3966
    ti = getutime() - ti;
3967
    if (do_benchmark) {
3968
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3969
    }
3970

    
3971
    return av_exit(0);
3972
}