Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 77ddf4df

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 "libavcodec/colorspace.h"
40
#include "libavutil/fifo.h"
41
#include "libavutil/avstring.h"
42
#include "libavformat/os_support.h"
43

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

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

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

    
66
#include "cmdutils.h"
67

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

    
71
#undef exit
72

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

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

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

    
90
static const OptionDef options[];
91

    
92
#define MAX_FILES 20
93

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

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

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

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

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

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

    
163
static int subtitle_disable = 0;
164
static char *subtitle_codec_name = NULL;
165
static char *subtitle_language = NULL;
166
static int subtitle_codec_tag = 0;
167

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

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

    
198
static int rate_emu = 0;
199

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

    
203
static int audio_volume = 256;
204

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

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

    
222
static unsigned int sws_flags = SWS_BICUBIC;
223

    
224
static int64_t timer_start;
225

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

    
230
static short *samples;
231

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

    
237
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
238

    
239
struct AVInputStream;
240

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

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

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

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

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

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

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

    
300
#if HAVE_TERMIOS_H
301

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

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

    
313
static volatile sig_atomic_t received_sigterm = 0;
314

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
424
    av_free(opt_names);
425

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

    
430
    av_free(video_standard);
431

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
528
        bsfc= bsfc->next;
529
    }
530

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

    
538
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
539

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
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
        picture2 = picture;
773
    }
774

    
775
    if (picture != picture2)
776
        *picture = *picture2;
777
    *bufp = buf;
778
}
779

    
780
/* we begin to correct av delay at this threshold */
781
#define AV_DELAY_MAX 0.100
782

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

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

    
802
    enc = ost->st->codec;
803

    
804
    if (!subtitle_out) {
805
        subtitle_out = av_malloc(subtitle_out_max_size);
806
    }
807

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

    
816
    for(i = 0; i < nb; i++) {
817
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
818
                                                    subtitle_out_max_size, sub);
819

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

    
837
static int bit_buffer_size= 1024*256;
838
static uint8_t *bit_buffer= NULL;
839

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

    
851
    avcodec_get_frame_defaults(&picture_crop_temp);
852
    avcodec_get_frame_defaults(&picture_pad_temp);
853

    
854
    enc = ost->st->codec;
855
    dec = ist->st->codec;
856

    
857
    /* by default, we output a single frame */
858
    nb_frames = 1;
859

    
860
    *frame_size = 0;
861

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

    
888
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
889
    if (nb_frames <= 0)
890
        return;
891

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

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

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

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

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

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

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

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

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

    
986
            if(ret>0){
987
                pkt.data= bit_buffer;
988
                pkt.size= ret;
989
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
990
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
991
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
992
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
993
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
994

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

    
1013
static double psnr(double d){
1014
    return -10.0*log(d)/log(10.0);
1015
}
1016

    
1017
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1018
                           int frame_size)
1019
{
1020
    AVCodecContext *enc;
1021
    int frame_number;
1022
    double ti1, bitrate, avg_bitrate;
1023

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

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

    
1040
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1041
        /* compute pts value */
1042
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1043
        if (ti1 < 0.01)
1044
            ti1 = 0.01;
1045

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

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

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

    
1081

    
1082
    oc = output_files[0];
1083

    
1084
    total_size = url_fsize(oc->pb);
1085
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1086
        total_size= url_ftell(oc->pb);
1087

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

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

    
1148
    if (verbose || is_last_report) {
1149
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1150

    
1151
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1152
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1153
            (double)total_size / 1024, ti1, bitrate);
1154

    
1155
        if (verbose > 1)
1156
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1157
                  nb_frames_dup, nb_frames_drop);
1158

    
1159
        if (verbose >= 0)
1160
            fprintf(stderr, "%s    \r", buf);
1161

    
1162
        fflush(stderr);
1163
    }
1164

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

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

    
1194
    if(ist->next_pts == AV_NOPTS_VALUE)
1195
        ist->next_pts= ist->pts;
1196

    
1197
    if (pkt == NULL) {
1198
        /* EOF handling */
1199
        av_init_packet(&avpkt);
1200
        avpkt.data = NULL;
1201
        avpkt.size = 0;
1202
        goto handle_eof;
1203
    } else {
1204
        avpkt = *pkt;
1205
    }
1206

    
1207
    if(pkt->dts != AV_NOPTS_VALUE)
1208
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1209

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

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

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

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

    
1306
        buffer_to_free = NULL;
1307
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1308
            pre_process_video_frame(ist, (AVPicture *)&picture,
1309
                                    &buffer_to_free);
1310
        }
1311

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

    
1326
        /* frame rate emulation */
1327
        if (rate_emu) {
1328
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1329
            int64_t now = av_gettime() - ist->start;
1330
            if (pts > now)
1331
                usleep(pts - now);
1332
        }
1333

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

    
1340
                ost = ost_table[i];
1341
                if (ost->source_index == ist_index) {
1342
                    os = output_files[ost->file_index];
1343

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

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

    
1375
                        av_init_packet(&opkt);
1376

    
1377
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1378
                            continue;
1379

    
1380
                        /* no reencoding needed : output the packet directly */
1381
                        /* force the input stream PTS */
1382

    
1383
                        avcodec_get_frame_defaults(&avframe);
1384
                        ost->st->codec->coded_frame= &avframe;
1385
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1386

    
1387
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1388
                            audio_size += data_size;
1389
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1390
                            video_size += data_size;
1391
                            ost->sync_opts++;
1392
                        }
1393

    
1394
                        opkt.stream_index= ost->index;
1395
                        if(pkt->pts != AV_NOPTS_VALUE)
1396
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1397
                        else
1398
                            opkt.pts= AV_NOPTS_VALUE;
1399

    
1400
                        if (pkt->dts == AV_NOPTS_VALUE)
1401
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1402
                        else
1403
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1404
                        opkt.dts -= ost_tb_start_time;
1405

    
1406
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1407
                        opkt.flags= pkt->flags;
1408

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

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

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

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

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

    
1462
                        switch(ost->st->codec->codec_type) {
1463
                        case CODEC_TYPE_AUDIO:
1464
                            fifo_bytes = av_fifo_size(ost->fifo);
1465
                            ret = 0;
1466
                            /* encode any samples remaining in fifo */
1467
                            if (fifo_bytes > 0) {
1468
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1469
                                int fs_tmp = enc->frame_size;
1470

    
1471
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1472
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1473
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1474
                                } else { /* pad */
1475
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1476
                                    if (samples_size < frame_bytes)
1477
                                        av_exit(1);
1478
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1479
                                }
1480

    
1481
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1482
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1483
                                                          ost->st->time_base.num, enc->sample_rate);
1484
                                enc->frame_size = fs_tmp;
1485
                            }
1486
                            if(ret <= 0) {
1487
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1488
                            }
1489
                            if (ret < 0) {
1490
                                fprintf(stderr, "Audio encoding failed\n");
1491
                                av_exit(1);
1492
                            }
1493
                            audio_size += ret;
1494
                            pkt.flags |= PKT_FLAG_KEY;
1495
                            break;
1496
                        case CODEC_TYPE_VIDEO:
1497
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1498
                            if (ret < 0) {
1499
                                fprintf(stderr, "Video encoding failed\n");
1500
                                av_exit(1);
1501
                            }
1502
                            video_size += ret;
1503
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1504
                                pkt.flags |= PKT_FLAG_KEY;
1505
                            if (ost->logfile && enc->stats_out) {
1506
                                fprintf(ost->logfile, "%s", enc->stats_out);
1507
                            }
1508
                            break;
1509
                        default:
1510
                            ret=-1;
1511
                        }
1512

    
1513
                        if(ret<=0)
1514
                            break;
1515
                        pkt.data= bit_buffer;
1516
                        pkt.size= ret;
1517
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1518
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1519
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1520
                    }
1521
                }
1522
            }
1523
        }
1524
    }
1525

    
1526
    return 0;
1527
 fail_decode:
1528
    return -1;
1529
}
1530

    
1531
static void print_sdp(AVFormatContext **avc, int n)
1532
{
1533
    char sdp[2048];
1534

    
1535
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1536
    printf("SDP:\n%s\n", sdp);
1537
    fflush(stdout);
1538
}
1539

    
1540
static int stream_index_from_inputs(AVFormatContext **input_files,
1541
                                    int nb_input_files,
1542
                                    AVInputFile *file_table,
1543
                                    AVInputStream **ist_table,
1544
                                    enum CodecType type,
1545
                                    int programid)
1546
{
1547
    int p, q, z;
1548
    for(z=0; z<nb_input_files; z++) {
1549
        AVFormatContext *ic = input_files[z];
1550
        for(p=0; p<ic->nb_programs; p++) {
1551
            AVProgram *program = ic->programs[p];
1552
            if(program->id != programid)
1553
                continue;
1554
            for(q=0; q<program->nb_stream_indexes; q++) {
1555
                int sidx = program->stream_index[q];
1556
                int ris = file_table[z].ist_index + sidx;
1557
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1558
                    return ris;
1559
            }
1560
        }
1561
    }
1562

    
1563
    return -1;
1564
}
1565

    
1566
/*
1567
 * The following code is the main loop of the file converter
1568
 */
1569
static int av_encode(AVFormatContext **output_files,
1570
                     int nb_output_files,
1571
                     AVFormatContext **input_files,
1572
                     int nb_input_files,
1573
                     AVStreamMap *stream_maps, int nb_stream_maps)
1574
{
1575
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1576
    AVFormatContext *is, *os;
1577
    AVCodecContext *codec, *icodec;
1578
    AVOutputStream *ost, **ost_table = NULL;
1579
    AVInputStream *ist, **ist_table = NULL;
1580
    AVInputFile *file_table;
1581
    char error[1024];
1582
    int key;
1583
    int want_sdp = 1;
1584
    uint8_t no_packet[MAX_FILES]={0};
1585
    int no_packet_count=0;
1586

    
1587
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1588
    if (!file_table)
1589
        goto fail;
1590

    
1591
    /* input stream init */
1592
    j = 0;
1593
    for(i=0;i<nb_input_files;i++) {
1594
        is = input_files[i];
1595
        file_table[i].ist_index = j;
1596
        file_table[i].nb_streams = is->nb_streams;
1597
        j += is->nb_streams;
1598
    }
1599
    nb_istreams = j;
1600

    
1601
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1602
    if (!ist_table)
1603
        goto fail;
1604

    
1605
    for(i=0;i<nb_istreams;i++) {
1606
        ist = av_mallocz(sizeof(AVInputStream));
1607
        if (!ist)
1608
            goto fail;
1609
        ist_table[i] = ist;
1610
    }
1611
    j = 0;
1612
    for(i=0;i<nb_input_files;i++) {
1613
        is = input_files[i];
1614
        for(k=0;k<is->nb_streams;k++) {
1615
            ist = ist_table[j++];
1616
            ist->st = is->streams[k];
1617
            ist->file_index = i;
1618
            ist->index = k;
1619
            ist->discard = 1; /* the stream is discarded by default
1620
                                 (changed later) */
1621

    
1622
            if (rate_emu) {
1623
                ist->start = av_gettime();
1624
            }
1625
        }
1626
    }
1627

    
1628
    /* output stream init */
1629
    nb_ostreams = 0;
1630
    for(i=0;i<nb_output_files;i++) {
1631
        os = output_files[i];
1632
        if (!os->nb_streams) {
1633
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1634
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1635
            av_exit(1);
1636
        }
1637
        nb_ostreams += os->nb_streams;
1638
    }
1639
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1640
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1641
        av_exit(1);
1642
    }
1643

    
1644
    /* Sanity check the mapping args -- do the input files & streams exist? */
1645
    for(i=0;i<nb_stream_maps;i++) {
1646
        int fi = stream_maps[i].file_index;
1647
        int si = stream_maps[i].stream_index;
1648

    
1649
        if (fi < 0 || fi > nb_input_files - 1 ||
1650
            si < 0 || si > file_table[fi].nb_streams - 1) {
1651
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1652
            av_exit(1);
1653
        }
1654
        fi = stream_maps[i].sync_file_index;
1655
        si = stream_maps[i].sync_stream_index;
1656
        if (fi < 0 || fi > nb_input_files - 1 ||
1657
            si < 0 || si > file_table[fi].nb_streams - 1) {
1658
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1659
            av_exit(1);
1660
        }
1661
    }
1662

    
1663
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1664
    if (!ost_table)
1665
        goto fail;
1666
    for(i=0;i<nb_ostreams;i++) {
1667
        ost = av_mallocz(sizeof(AVOutputStream));
1668
        if (!ost)
1669
            goto fail;
1670
        ost_table[i] = ost;
1671
    }
1672

    
1673
    n = 0;
1674
    for(k=0;k<nb_output_files;k++) {
1675
        os = output_files[k];
1676
        for(i=0;i<os->nb_streams;i++,n++) {
1677
            int found;
1678
            ost = ost_table[n];
1679
            ost->file_index = k;
1680
            ost->index = i;
1681
            ost->st = os->streams[i];
1682
            if (nb_stream_maps > 0) {
1683
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1684
                    stream_maps[n].stream_index;
1685

    
1686
                /* Sanity check that the stream types match */
1687
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1688
                    int i= ost->file_index;
1689
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1690
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1691
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1692
                        ost->file_index, ost->index);
1693
                    av_exit(1);
1694
                }
1695

    
1696
            } else {
1697
                if(opt_programid) {
1698
                    found = 0;
1699
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1700
                    if(j != -1) {
1701
                        ost->source_index = j;
1702
                        found = 1;
1703
                    }
1704
                } else {
1705
                    /* get corresponding input stream index : we select the first one with the right type */
1706
                    found = 0;
1707
                    for(j=0;j<nb_istreams;j++) {
1708
                        ist = ist_table[j];
1709
                        if (ist->discard &&
1710
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1711
                            ost->source_index = j;
1712
                            found = 1;
1713
                            break;
1714
                        }
1715
                    }
1716
                }
1717

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

    
1746
    /* for each output stream, we compute the right encoding parameters */
1747
    for(i=0;i<nb_ostreams;i++) {
1748
        AVMetadataTag *lang;
1749
        ost = ost_table[i];
1750
        os = output_files[ost->file_index];
1751
        ist = ist_table[ost->source_index];
1752

    
1753
        codec = ost->st->codec;
1754
        icodec = ist->st->codec;
1755

    
1756
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1757
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1758
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1759

    
1760
        ost->st->disposition = ist->st->disposition;
1761
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1762
        codec->chroma_sample_location = icodec->chroma_sample_location;
1763

    
1764
        if (ost->st->stream_copy) {
1765
            /* if stream_copy is selected, no need to decode or encode */
1766
            codec->codec_id = icodec->codec_id;
1767
            codec->codec_type = icodec->codec_type;
1768

    
1769
            if(!codec->codec_tag){
1770
                if(   !os->oformat->codec_tag
1771
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1772
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1773
                    codec->codec_tag = icodec->codec_tag;
1774
            }
1775

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

    
1897
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1898
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1899
                         i);
1900
                if (codec->flags & CODEC_FLAG_PASS1) {
1901
                    f = fopen(logfilename, "w");
1902
                    if (!f) {
1903
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1904
                        av_exit(1);
1905
                    }
1906
                    ost->logfile = f;
1907
                } else {
1908
                    /* read the log file */
1909
                    f = fopen(logfilename, "r");
1910
                    if (!f) {
1911
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1912
                        av_exit(1);
1913
                    }
1914
                    fseek(f, 0, SEEK_END);
1915
                    size = ftell(f);
1916
                    fseek(f, 0, SEEK_SET);
1917
                    logbuffer = av_malloc(size + 1);
1918
                    if (!logbuffer) {
1919
                        fprintf(stderr, "Could not allocate log buffer\n");
1920
                        av_exit(1);
1921
                    }
1922
                    size = fread(logbuffer, 1, size, f);
1923
                    fclose(f);
1924
                    logbuffer[size] = '\0';
1925
                    codec->stats_in = logbuffer;
1926
                }
1927
            }
1928
        }
1929
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1930
            int size= codec->width * codec->height;
1931
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1932
        }
1933
    }
1934

    
1935
    if (!bit_buffer)
1936
        bit_buffer = av_malloc(bit_buffer_size);
1937
    if (!bit_buffer) {
1938
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
1939
                bit_buffer_size);
1940
        ret = AVERROR(ENOMEM);
1941
        goto fail;
1942
    }
1943

    
1944
    /* open each encoder */
1945
    for(i=0;i<nb_ostreams;i++) {
1946
        ost = ost_table[i];
1947
        if (ost->encoding_needed) {
1948
            AVCodec *codec = output_codecs[i];
1949
            if (!codec)
1950
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
1951
            if (!codec) {
1952
                snprintf(error, sizeof(error), "Unsupported codec for output stream #%d.%d",
1953
                        ost->file_index, ost->index);
1954
                ret = AVERROR(EINVAL);
1955
                goto dump_format;
1956
            }
1957
            if (avcodec_open(ost->st->codec, codec) < 0) {
1958
                snprintf(error, sizeof(error), "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1959
                        ost->file_index, ost->index);
1960
                ret = AVERROR(EINVAL);
1961
                goto dump_format;
1962
            }
1963
            extra_size += ost->st->codec->extradata_size;
1964
        }
1965
    }
1966

    
1967
    /* open each decoder */
1968
    for(i=0;i<nb_istreams;i++) {
1969
        ist = ist_table[i];
1970
        if (ist->decoding_needed) {
1971
            AVCodec *codec = input_codecs[i];
1972
            if (!codec)
1973
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
1974
            if (!codec) {
1975
                snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
1976
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1977
                ret = AVERROR(EINVAL);
1978
                goto dump_format;
1979
            }
1980
            if (avcodec_open(ist->st->codec, codec) < 0) {
1981
                snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
1982
                        ist->file_index, ist->index);
1983
                ret = AVERROR(EINVAL);
1984
                goto dump_format;
1985
            }
1986
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1987
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1988
        }
1989
    }
1990

    
1991
    /* init pts */
1992
    for(i=0;i<nb_istreams;i++) {
1993
        ist = ist_table[i];
1994
        ist->pts = 0;
1995
        ist->next_pts = AV_NOPTS_VALUE;
1996
        ist->is_start = 1;
1997
    }
1998

    
1999
    /* set meta data information from input file if required */
2000
    for (i=0;i<nb_meta_data_maps;i++) {
2001
        AVFormatContext *out_file;
2002
        AVFormatContext *in_file;
2003
        AVMetadataTag *mtag;
2004

    
2005
        int out_file_index = meta_data_maps[i].out_file;
2006
        int in_file_index = meta_data_maps[i].in_file;
2007
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2008
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2009
                     out_file_index, out_file_index, in_file_index);
2010
            ret = AVERROR(EINVAL);
2011
            goto dump_format;
2012
        }
2013
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2014
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2015
                     in_file_index, out_file_index, in_file_index);
2016
            ret = AVERROR(EINVAL);
2017
            goto dump_format;
2018
        }
2019

    
2020
        out_file = output_files[out_file_index];
2021
        in_file = input_files[in_file_index];
2022

    
2023

    
2024
        mtag=NULL;
2025
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2026
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2027
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2028
                                    in_file->iformat->metadata_conv);
2029
    }
2030

    
2031
    /* open files and write file headers */
2032
    for(i=0;i<nb_output_files;i++) {
2033
        os = output_files[i];
2034
        if (av_write_header(os) < 0) {
2035
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2036
            ret = AVERROR(EINVAL);
2037
            goto dump_format;
2038
        }
2039
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2040
            want_sdp = 0;
2041
        }
2042
    }
2043

    
2044
 dump_format:
2045
    /* dump the file output parameters - cannot be done before in case
2046
       of stream copy */
2047
    for(i=0;i<nb_output_files;i++) {
2048
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2049
    }
2050

    
2051
    /* dump the stream mapping */
2052
    if (verbose >= 0) {
2053
        fprintf(stderr, "Stream mapping:\n");
2054
        for(i=0;i<nb_ostreams;i++) {
2055
            ost = ost_table[i];
2056
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2057
                    ist_table[ost->source_index]->file_index,
2058
                    ist_table[ost->source_index]->index,
2059
                    ost->file_index,
2060
                    ost->index);
2061
            if (ost->sync_ist != ist_table[ost->source_index])
2062
                fprintf(stderr, " [sync #%d.%d]",
2063
                        ost->sync_ist->file_index,
2064
                        ost->sync_ist->index);
2065
            fprintf(stderr, "\n");
2066
        }
2067
    }
2068

    
2069
    if (ret) {
2070
        fprintf(stderr, "%s\n", error);
2071
        goto fail;
2072
    }
2073

    
2074
    if (want_sdp) {
2075
        print_sdp(output_files, nb_output_files);
2076
    }
2077

    
2078
    if (!using_stdin && verbose >= 0) {
2079
        fprintf(stderr, "Press [q] to stop encoding\n");
2080
        url_set_interrupt_cb(decode_interrupt_cb);
2081
    }
2082
    term_init();
2083

    
2084
    timer_start = av_gettime();
2085

    
2086
    for(; received_sigterm == 0;) {
2087
        int file_index, ist_index;
2088
        AVPacket pkt;
2089
        double ipts_min;
2090
        double opts_min;
2091

    
2092
    redo:
2093
        ipts_min= 1e100;
2094
        opts_min= 1e100;
2095
        /* if 'q' pressed, exits */
2096
        if (!using_stdin) {
2097
            if (q_pressed)
2098
                break;
2099
            /* read_key() returns 0 on EOF */
2100
            key = read_key();
2101
            if (key == 'q')
2102
                break;
2103
        }
2104

    
2105
        /* select the stream that we must read now by looking at the
2106
           smallest output pts */
2107
        file_index = -1;
2108
        for(i=0;i<nb_ostreams;i++) {
2109
            double ipts, opts;
2110
            ost = ost_table[i];
2111
            os = output_files[ost->file_index];
2112
            ist = ist_table[ost->source_index];
2113
            if(no_packet[ist->file_index])
2114
                continue;
2115
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2116
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2117
            else
2118
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2119
            ipts = (double)ist->pts;
2120
            if (!file_table[ist->file_index].eof_reached){
2121
                if(ipts < ipts_min) {
2122
                    ipts_min = ipts;
2123
                    if(input_sync ) file_index = ist->file_index;
2124
                }
2125
                if(opts < opts_min) {
2126
                    opts_min = opts;
2127
                    if(!input_sync) file_index = ist->file_index;
2128
                }
2129
            }
2130
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2131
                file_index= -1;
2132
                break;
2133
            }
2134
        }
2135
        /* if none, if is finished */
2136
        if (file_index < 0) {
2137
            if(no_packet_count){
2138
                no_packet_count=0;
2139
                memset(no_packet, 0, sizeof(no_packet));
2140
                usleep(10000);
2141
                continue;
2142
            }
2143
            break;
2144
        }
2145

    
2146
        /* finish if recording time exhausted */
2147
        if (opts_min >= (recording_time / 1000000.0))
2148
            break;
2149

    
2150
        /* finish if limit size exhausted */
2151
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2152
            break;
2153

    
2154
        /* read a frame from it and output it in the fifo */
2155
        is = input_files[file_index];
2156
        ret= av_read_frame(is, &pkt);
2157
        if(ret == AVERROR(EAGAIN)){
2158
            no_packet[file_index]=1;
2159
            no_packet_count++;
2160
            continue;
2161
        }
2162
        if (ret < 0) {
2163
            file_table[file_index].eof_reached = 1;
2164
            if (opt_shortest)
2165
                break;
2166
            else
2167
                continue;
2168
        }
2169

    
2170
        no_packet_count=0;
2171
        memset(no_packet, 0, sizeof(no_packet));
2172

    
2173
        if (do_pkt_dump) {
2174
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2175
        }
2176
        /* the following test is needed in case new streams appear
2177
           dynamically in stream : we ignore them */
2178
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2179
            goto discard_packet;
2180
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2181
        ist = ist_table[ist_index];
2182
        if (ist->discard)
2183
            goto discard_packet;
2184

    
2185
        if (pkt.dts != AV_NOPTS_VALUE)
2186
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2187
        if (pkt.pts != AV_NOPTS_VALUE)
2188
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2189

    
2190
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2191
            if(pkt.pts != AV_NOPTS_VALUE)
2192
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2193
            if(pkt.dts != AV_NOPTS_VALUE)
2194
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2195
        }
2196

    
2197
//        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);
2198
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2199
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2200
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2201
            int64_t delta= pkt_dts - ist->next_pts;
2202
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2203
                input_files_ts_offset[ist->file_index]-= delta;
2204
                if (verbose > 2)
2205
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2206
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2207
                if(pkt.pts != AV_NOPTS_VALUE)
2208
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2209
            }
2210
        }
2211

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

    
2215
            if (verbose >= 0)
2216
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2217
                        ist->file_index, ist->index);
2218
            if (exit_on_error)
2219
                av_exit(1);
2220
            av_free_packet(&pkt);
2221
            goto redo;
2222
        }
2223

    
2224
    discard_packet:
2225
        av_free_packet(&pkt);
2226

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

    
2231
    /* at the end of stream, we must flush the decoder buffers */
2232
    for(i=0;i<nb_istreams;i++) {
2233
        ist = ist_table[i];
2234
        if (ist->decoding_needed) {
2235
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2236
        }
2237
    }
2238

    
2239
    term_exit();
2240

    
2241
    /* write the trailer if needed and close file */
2242
    for(i=0;i<nb_output_files;i++) {
2243
        os = output_files[i];
2244
        av_write_trailer(os);
2245
    }
2246

    
2247
    /* dump report by using the first video and audio streams */
2248
    print_report(output_files, ost_table, nb_ostreams, 1);
2249

    
2250
    /* close each encoder */
2251
    for(i=0;i<nb_ostreams;i++) {
2252
        ost = ost_table[i];
2253
        if (ost->encoding_needed) {
2254
            av_freep(&ost->st->codec->stats_in);
2255
            avcodec_close(ost->st->codec);
2256
        }
2257
    }
2258

    
2259
    /* close each decoder */
2260
    for(i=0;i<nb_istreams;i++) {
2261
        ist = ist_table[i];
2262
        if (ist->decoding_needed) {
2263
            avcodec_close(ist->st->codec);
2264
        }
2265
    }
2266

    
2267
    /* finished ! */
2268
    ret = 0;
2269

    
2270
 fail:
2271
    av_freep(&bit_buffer);
2272
    av_free(file_table);
2273

    
2274
    if (ist_table) {
2275
        for(i=0;i<nb_istreams;i++) {
2276
            ist = ist_table[i];
2277
            av_free(ist);
2278
        }
2279
        av_free(ist_table);
2280
    }
2281
    if (ost_table) {
2282
        for(i=0;i<nb_ostreams;i++) {
2283
            ost = ost_table[i];
2284
            if (ost) {
2285
                if (ost->logfile) {
2286
                    fclose(ost->logfile);
2287
                    ost->logfile = NULL;
2288
                }
2289
                av_fifo_free(ost->fifo); /* works even if fifo is not
2290
                                             initialized but set to zero */
2291
                av_free(ost->pict_tmp.data[0]);
2292
                if (ost->video_resample)
2293
                    sws_freeContext(ost->img_resample_ctx);
2294
                if (ost->resample)
2295
                    audio_resample_close(ost->resample);
2296
                if (ost->reformat_ctx)
2297
                    av_audio_convert_free(ost->reformat_ctx);
2298
                av_free(ost);
2299
            }
2300
        }
2301
        av_free(ost_table);
2302
    }
2303
    return ret;
2304
}
2305

    
2306
#if 0
2307
int file_read(const char *filename)
2308
{
2309
    URLContext *h;
2310
    unsigned char buffer[1024];
2311
    int len, i;
2312

2313
    if (url_open(&h, filename, O_RDONLY) < 0) {
2314
        printf("could not open '%s'\n", filename);
2315
        return -1;
2316
    }
2317
    for(;;) {
2318
        len = url_read(h, buffer, sizeof(buffer));
2319
        if (len <= 0)
2320
            break;
2321
        for(i=0;i<len;i++) putchar(buffer[i]);
2322
    }
2323
    url_close(h);
2324
    return 0;
2325
}
2326
#endif
2327

    
2328
static void opt_format(const char *arg)
2329
{
2330
    /* compatibility stuff for pgmyuv */
2331
    if (!strcmp(arg, "pgmyuv")) {
2332
        pgmyuv_compatibility_hack=1;
2333
//        opt_image_format(arg);
2334
        arg = "image2";
2335
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2336
    }
2337

    
2338
    file_iformat = av_find_input_format(arg);
2339
    file_oformat = guess_format(arg, NULL, NULL);
2340
    if (!file_iformat && !file_oformat) {
2341
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2342
        av_exit(1);
2343
    }
2344
}
2345

    
2346
static void opt_video_rc_override_string(const char *arg)
2347
{
2348
    video_rc_override_string = arg;
2349
}
2350

    
2351
static int opt_me_threshold(const char *opt, const char *arg)
2352
{
2353
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2354
    return 0;
2355
}
2356

    
2357
static int opt_loglevel(const char *opt, const char *arg)
2358
{
2359
    const struct { const char *name; int level; } const log_levels[] = {
2360
        { "quiet"  , AV_LOG_QUIET   },
2361
        { "panic"  , AV_LOG_PANIC   },
2362
        { "fatal"  , AV_LOG_FATAL   },
2363
        { "error"  , AV_LOG_ERROR   },
2364
        { "warning", AV_LOG_WARNING },
2365
        { "info"   , AV_LOG_INFO    },
2366
        { "verbose", AV_LOG_VERBOSE },
2367
        { "debug"  , AV_LOG_DEBUG   },
2368
    };
2369
    char *tail;
2370
    int level;
2371
    int i;
2372

    
2373
    for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
2374
        if (!strcmp(log_levels[i].name, arg)) {
2375
            av_log_set_level(log_levels[i].level);
2376
            return 0;
2377
        }
2378
    }
2379

    
2380
    level = strtol(arg, &tail, 10);
2381
    if (*tail) {
2382
        fprintf(stderr, "Invalid loglevel \"%s\". "
2383
                        "Possible levels are numbers or:\n", arg);
2384
        for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
2385
            fprintf(stderr, "\"%s\"\n", log_levels[i].name);
2386
        av_exit(1);
2387
    }
2388
    av_log_set_level(level);
2389
    return 0;
2390
}
2391

    
2392
static int opt_verbose(const char *opt, const char *arg)
2393
{
2394
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2395
    return 0;
2396
}
2397

    
2398
static int opt_frame_rate(const char *opt, const char *arg)
2399
{
2400
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2401
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2402
        av_exit(1);
2403
    }
2404
    return 0;
2405
}
2406

    
2407
static int opt_bitrate(const char *opt, const char *arg)
2408
{
2409
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2410

    
2411
    opt_default(opt, arg);
2412

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

    
2416
    return 0;
2417
}
2418

    
2419
static void opt_frame_crop_top(const char *arg)
2420
{
2421
    frame_topBand = atoi(arg);
2422
    if (frame_topBand < 0) {
2423
        fprintf(stderr, "Incorrect top crop size\n");
2424
        av_exit(1);
2425
    }
2426
    if ((frame_topBand) >= frame_height){
2427
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2428
        av_exit(1);
2429
    }
2430
    frame_height -= frame_topBand;
2431
}
2432

    
2433
static void opt_frame_crop_bottom(const char *arg)
2434
{
2435
    frame_bottomBand = atoi(arg);
2436
    if (frame_bottomBand < 0) {
2437
        fprintf(stderr, "Incorrect bottom crop size\n");
2438
        av_exit(1);
2439
    }
2440
    if ((frame_bottomBand) >= frame_height){
2441
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2442
        av_exit(1);
2443
    }
2444
    frame_height -= frame_bottomBand;
2445
}
2446

    
2447
static void opt_frame_crop_left(const char *arg)
2448
{
2449
    frame_leftBand = atoi(arg);
2450
    if (frame_leftBand < 0) {
2451
        fprintf(stderr, "Incorrect left crop size\n");
2452
        av_exit(1);
2453
    }
2454
    if ((frame_leftBand) >= frame_width){
2455
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2456
        av_exit(1);
2457
    }
2458
    frame_width -= frame_leftBand;
2459
}
2460

    
2461
static void opt_frame_crop_right(const char *arg)
2462
{
2463
    frame_rightBand = atoi(arg);
2464
    if (frame_rightBand < 0) {
2465
        fprintf(stderr, "Incorrect right crop size\n");
2466
        av_exit(1);
2467
    }
2468
    if ((frame_rightBand) >= frame_width){
2469
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2470
        av_exit(1);
2471
    }
2472
    frame_width -= frame_rightBand;
2473
}
2474

    
2475
static void opt_frame_size(const char *arg)
2476
{
2477
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2478
        fprintf(stderr, "Incorrect frame size\n");
2479
        av_exit(1);
2480
    }
2481
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2482
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2483
        av_exit(1);
2484
    }
2485
}
2486

    
2487
static void opt_pad_color(const char *arg) {
2488
    /* Input is expected to be six hex digits similar to
2489
       how colors are expressed in html tags (but without the #) */
2490
    int rgb = strtol(arg, NULL, 16);
2491
    int r,g,b;
2492

    
2493
    r = (rgb >> 16);
2494
    g = ((rgb >> 8) & 255);
2495
    b = (rgb & 255);
2496

    
2497
    padcolor[0] = RGB_TO_Y(r,g,b);
2498
    padcolor[1] = RGB_TO_U(r,g,b,0);
2499
    padcolor[2] = RGB_TO_V(r,g,b,0);
2500
}
2501

    
2502
static void opt_frame_pad_top(const char *arg)
2503
{
2504
    frame_padtop = atoi(arg);
2505
    if (frame_padtop < 0) {
2506
        fprintf(stderr, "Incorrect top pad size\n");
2507
        av_exit(1);
2508
    }
2509
}
2510

    
2511
static void opt_frame_pad_bottom(const char *arg)
2512
{
2513
    frame_padbottom = atoi(arg);
2514
    if (frame_padbottom < 0) {
2515
        fprintf(stderr, "Incorrect bottom pad size\n");
2516
        av_exit(1);
2517
    }
2518
}
2519

    
2520

    
2521
static void opt_frame_pad_left(const char *arg)
2522
{
2523
    frame_padleft = atoi(arg);
2524
    if (frame_padleft < 0) {
2525
        fprintf(stderr, "Incorrect left pad size\n");
2526
        av_exit(1);
2527
    }
2528
}
2529

    
2530

    
2531
static void opt_frame_pad_right(const char *arg)
2532
{
2533
    frame_padright = atoi(arg);
2534
    if (frame_padright < 0) {
2535
        fprintf(stderr, "Incorrect right pad size\n");
2536
        av_exit(1);
2537
    }
2538
}
2539

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

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

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

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

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

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

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

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

    
2603
    return 0;
2604
}
2605

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2849
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2850

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

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

    
2869
    ic->loop_input = loop_input;
2870

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

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

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

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

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

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

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

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

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

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

    
2973
    video_channel = 0;
2974

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

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

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

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

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

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

    
3035
    video_enc = st->codec;
3036

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

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

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

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

    
3070
        video_enc->codec_id = codec_id;
3071

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3326
    oc = avformat_alloc_context();
3327

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

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

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

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

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

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

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

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

    
3390
        oc->timestamp = rec_timestamp;
3391

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

    
3399
    output_files[nb_output_files++] = oc;
3400

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

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

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

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

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

    
3450
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3451

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3662

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

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

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

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

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

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

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

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

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

    
3691
        opt_format("dv");
3692

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

    
3698
        audio_sample_rate = 48000;
3699
        audio_channels = 2;
3700

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

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

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

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

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

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

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

    
3740
    *bsfp= bsfc;
3741

    
3742
    return 0;
3743
}
3744

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

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

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

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

    
3797
    fclose(f);
3798

    
3799
    return 0;
3800
}
3801

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3947
    show_banner();
3948

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

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

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

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

    
3972
    return av_exit(0);
3973
}