Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 352666c1

History | View | Annotate | Download (143 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
    int resample_width;
259

    
260
    /* full frame size of first frame */
261
    int original_height;
262
    int original_width;
263

    
264
    /* cropping area sizes */
265
    int video_crop;
266
    int topBand;
267
    int bottomBand;
268
    int leftBand;
269
    int rightBand;
270

    
271
    /* cropping area of first frame */
272
    int original_topBand;
273
    int original_bottomBand;
274
    int original_leftBand;
275
    int original_rightBand;
276

    
277
    /* padding area sizes */
278
    int video_pad;
279
    int padtop;
280
    int padbottom;
281
    int padleft;
282
    int padright;
283

    
284
    /* audio only */
285
    int audio_resample;
286
    ReSampleContext *resample; /* for audio resampling */
287
    int reformat_pair;
288
    AVAudioConvert *reformat_ctx;
289
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
290
    FILE *logfile;
291
} AVOutputStream;
292

    
293
typedef struct AVInputStream {
294
    int file_index;
295
    int index;
296
    AVStream *st;
297
    int discard;             /* true if stream data should be discarded */
298
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
299
    int64_t sample_index;      /* current sample */
300

    
301
    int64_t       start;     /* time when read started */
302
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
303
                                is not defined */
304
    int64_t       pts;       /* current pts */
305
    int is_start;            /* is 1 at the start and after a discontinuity */
306
} AVInputStream;
307

    
308
typedef struct AVInputFile {
309
    int eof_reached;      /* true if eof reached */
310
    int ist_index;        /* index of first stream in ist_table */
311
    int buffer_size;      /* current total buffer size */
312
    int nb_streams;       /* nb streams we are aware of */
313
} AVInputFile;
314

    
315
#if HAVE_TERMIOS_H
316

    
317
/* init terminal so that we can grab keys */
318
static struct termios oldtty;
319
#endif
320

    
321
static void term_exit(void)
322
{
323
#if HAVE_TERMIOS_H
324
    tcsetattr (0, TCSANOW, &oldtty);
325
#endif
326
}
327

    
328
static volatile sig_atomic_t received_sigterm = 0;
329

    
330
static void
331
sigterm_handler(int sig)
332
{
333
    received_sigterm = sig;
334
    term_exit();
335
}
336

    
337
static void term_init(void)
338
{
339
#if HAVE_TERMIOS_H
340
    struct termios tty;
341

    
342
    tcgetattr (0, &tty);
343
    oldtty = tty;
344

    
345
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
346
                          |INLCR|IGNCR|ICRNL|IXON);
347
    tty.c_oflag |= OPOST;
348
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
349
    tty.c_cflag &= ~(CSIZE|PARENB);
350
    tty.c_cflag |= CS8;
351
    tty.c_cc[VMIN] = 1;
352
    tty.c_cc[VTIME] = 0;
353

    
354
    tcsetattr (0, TCSANOW, &tty);
355
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
356
#endif
357

    
358
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
359
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
360
    /*
361
    register a function to be called at normal program termination
362
    */
363
    atexit(term_exit);
364
#if CONFIG_BEOS_NETSERVER
365
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
366
#endif
367
}
368

    
369
/* read a key without blocking */
370
static int read_key(void)
371
{
372
#if HAVE_TERMIOS_H
373
    int n = 1;
374
    unsigned char ch;
375
#if !CONFIG_BEOS_NETSERVER
376
    struct timeval tv;
377
    fd_set rfds;
378

    
379
    FD_ZERO(&rfds);
380
    FD_SET(0, &rfds);
381
    tv.tv_sec = 0;
382
    tv.tv_usec = 0;
383
    n = select(1, &rfds, NULL, NULL, &tv);
384
#endif
385
    if (n > 0) {
386
        n = read(0, &ch, 1);
387
        if (n == 1)
388
            return ch;
389

    
390
        return n;
391
    }
392
#elif HAVE_CONIO_H
393
    if(kbhit())
394
        return(getch());
395
#endif
396
    return -1;
397
}
398

    
399
static int decode_interrupt_cb(void)
400
{
401
    return q_pressed || (q_pressed = read_key() == 'q');
402
}
403

    
404
static int av_exit(int ret)
405
{
406
    int i;
407

    
408
    /* close files */
409
    for(i=0;i<nb_output_files;i++) {
410
        /* maybe av_close_output_file ??? */
411
        AVFormatContext *s = output_files[i];
412
        int j;
413
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
414
            url_fclose(s->pb);
415
        for(j=0;j<s->nb_streams;j++) {
416
            av_metadata_free(&s->streams[j]->metadata);
417
            av_free(s->streams[j]->codec);
418
            av_free(s->streams[j]);
419
        }
420
        for(j=0;j<s->nb_programs;j++) {
421
            av_metadata_free(&s->programs[j]->metadata);
422
        }
423
        for(j=0;j<s->nb_chapters;j++) {
424
            av_metadata_free(&s->chapters[j]->metadata);
425
        }
426
        av_metadata_free(&s->metadata);
427
        av_free(s);
428
    }
429
    for(i=0;i<nb_input_files;i++)
430
        av_close_input_file(input_files[i]);
431

    
432
    av_free(intra_matrix);
433
    av_free(inter_matrix);
434

    
435
    if (vstats_file)
436
        fclose(vstats_file);
437
    av_free(vstats_filename);
438

    
439
    av_free(opt_names);
440

    
441
    av_free(video_codec_name);
442
    av_free(audio_codec_name);
443
    av_free(subtitle_codec_name);
444

    
445
    av_free(video_standard);
446

    
447
#if CONFIG_POWERPC_PERF
448
    void powerpc_display_perf_report(void);
449
    powerpc_display_perf_report();
450
#endif /* CONFIG_POWERPC_PERF */
451

    
452
    for (i=0;i<CODEC_TYPE_NB;i++)
453
        av_free(avcodec_opts[i]);
454
    av_free(avformat_opts);
455
    av_free(sws_opts);
456
    av_free(audio_buf);
457
    av_free(audio_out);
458
    av_free(audio_out2);
459
    av_free(samples);
460

    
461
    if (received_sigterm) {
462
        fprintf(stderr,
463
            "Received signal %d: terminating.\n",
464
            (int) received_sigterm);
465
        exit (255);
466
    }
467

    
468
    exit(ret); /* not all OS-es handle main() return value */
469
    return ret;
470
}
471

    
472
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
473
{
474
    int i, err;
475
    AVFormatContext *ic;
476
    int nopts = 0;
477

    
478
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
479
    if (err < 0)
480
        return err;
481
    /* copy stream format */
482
    s->nb_streams = ic->nb_streams;
483
    for(i=0;i<ic->nb_streams;i++) {
484
        AVStream *st;
485

    
486
        // FIXME: a more elegant solution is needed
487
        st = av_mallocz(sizeof(AVStream));
488
        memcpy(st, ic->streams[i], sizeof(AVStream));
489
        st->codec = avcodec_alloc_context();
490
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
491
        s->streams[i] = st;
492

    
493
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
494
            st->stream_copy = 1;
495
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
496
            st->stream_copy = 1;
497

    
498
        if(!st->codec->thread_count)
499
            st->codec->thread_count = 1;
500
        if(st->codec->thread_count>1)
501
            avcodec_thread_init(st->codec, st->codec->thread_count);
502

    
503
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
504
            nopts = 1;
505
    }
506

    
507
    if (!nopts)
508
        s->timestamp = av_gettime();
509

    
510
    av_close_input_file(ic);
511
    return 0;
512
}
513

    
514
static double
515
get_sync_ipts(const AVOutputStream *ost)
516
{
517
    const AVInputStream *ist = ost->sync_ist;
518
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
519
}
520

    
521
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
522
    int ret;
523

    
524
    while(bsfc){
525
        AVPacket new_pkt= *pkt;
526
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
527
                                          &new_pkt.data, &new_pkt.size,
528
                                          pkt->data, pkt->size,
529
                                          pkt->flags & PKT_FLAG_KEY);
530
        if(a>0){
531
            av_free_packet(pkt);
532
            new_pkt.destruct= av_destruct_packet;
533
        } else if(a<0){
534
            fprintf(stderr, "%s failed for stream %d, codec %s",
535
                    bsfc->filter->name, pkt->stream_index,
536
                    avctx->codec ? avctx->codec->name : "copy");
537
            print_error("", a);
538
            if (exit_on_error)
539
                av_exit(1);
540
        }
541
        *pkt= new_pkt;
542

    
543
        bsfc= bsfc->next;
544
    }
545

    
546
    ret= av_interleaved_write_frame(s, pkt);
547
    if(ret < 0){
548
        print_error("av_interleaved_write_frame()", ret);
549
        av_exit(1);
550
    }
551
}
552

    
553
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
554

    
555
static void do_audio_out(AVFormatContext *s,
556
                         AVOutputStream *ost,
557
                         AVInputStream *ist,
558
                         unsigned char *buf, int size)
559
{
560
    uint8_t *buftmp;
561
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
562

    
563
    int size_out, frame_bytes, ret;
564
    AVCodecContext *enc= ost->st->codec;
565
    AVCodecContext *dec= ist->st->codec;
566
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
567
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
568

    
569
    /* SC: dynamic allocation of buffers */
570
    if (!audio_buf)
571
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
572
    if (!audio_out)
573
        audio_out = av_malloc(audio_out_size);
574
    if (!audio_buf || !audio_out)
575
        return;               /* Should signal an error ! */
576

    
577
    if (enc->channels != dec->channels)
578
        ost->audio_resample = 1;
579

    
580
    if (ost->audio_resample && !ost->resample) {
581
        if (dec->sample_fmt != SAMPLE_FMT_S16)
582
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
583
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
584
                                               enc->sample_rate, dec->sample_rate,
585
                                               enc->sample_fmt,  dec->sample_fmt,
586
                                               16, 10, 0, 0.8);
587
        if (!ost->resample) {
588
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
589
                    dec->channels, dec->sample_rate,
590
                    enc->channels, enc->sample_rate);
591
            av_exit(1);
592
        }
593
    }
594

    
595
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
596
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
597
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
598
        if (!audio_out2)
599
            audio_out2 = av_malloc(audio_out_size);
600
        if (!audio_out2)
601
            av_exit(1);
602
        if (ost->reformat_ctx)
603
            av_audio_convert_free(ost->reformat_ctx);
604
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
605
                                                   dec->sample_fmt, 1, NULL, 0);
606
        if (!ost->reformat_ctx) {
607
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
608
                avcodec_get_sample_fmt_name(dec->sample_fmt),
609
                avcodec_get_sample_fmt_name(enc->sample_fmt));
610
            av_exit(1);
611
        }
612
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
613
    }
614

    
615
    if(audio_sync_method){
616
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
617
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
618
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
619
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
620

    
621
        //FIXME resample delay
622
        if(fabs(delta) > 50){
623
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
624
                if(byte_delta < 0){
625
                    byte_delta= FFMAX(byte_delta, -size);
626
                    size += byte_delta;
627
                    buf  -= byte_delta;
628
                    if(verbose > 2)
629
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
630
                    if(!size)
631
                        return;
632
                    ist->is_start=0;
633
                }else{
634
                    static uint8_t *input_tmp= NULL;
635
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
636

    
637
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
638
                        ist->is_start=0;
639
                    else
640
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
641

    
642
                    memset(input_tmp, 0, byte_delta);
643
                    memcpy(input_tmp + byte_delta, buf, size);
644
                    buf= input_tmp;
645
                    size += byte_delta;
646
                    if(verbose > 2)
647
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
648
                }
649
            }else if(audio_sync_method>1){
650
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
651
                assert(ost->audio_resample);
652
                if(verbose > 2)
653
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
654
//                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));
655
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
656
            }
657
        }
658
    }else
659
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
660
                        - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
661

    
662
    if (ost->audio_resample) {
663
        buftmp = audio_buf;
664
        size_out = audio_resample(ost->resample,
665
                                  (short *)buftmp, (short *)buf,
666
                                  size / (ist->st->codec->channels * isize));
667
        size_out = size_out * enc->channels * osize;
668
    } else {
669
        buftmp = buf;
670
        size_out = size;
671
    }
672

    
673
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
674
        const void *ibuf[6]= {buftmp};
675
        void *obuf[6]= {audio_out2};
676
        int istride[6]= {isize};
677
        int ostride[6]= {osize};
678
        int len= size_out/istride[0];
679
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
680
            printf("av_audio_convert() failed\n");
681
            if (exit_on_error)
682
                av_exit(1);
683
            return;
684
        }
685
        buftmp = audio_out2;
686
        size_out = len*osize;
687
    }
688

    
689
    /* now encode as many frames as possible */
690
    if (enc->frame_size > 1) {
691
        /* output resampled raw samples */
692
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
693
            fprintf(stderr, "av_fifo_realloc2() failed\n");
694
            av_exit(1);
695
        }
696
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
697

    
698
        frame_bytes = enc->frame_size * osize * enc->channels;
699

    
700
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
701
            AVPacket pkt;
702
            av_init_packet(&pkt);
703

    
704
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
705

    
706
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
707

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

    
723
            ost->sync_opts += enc->frame_size;
724
        }
725
    } else {
726
        AVPacket pkt;
727
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
728
        av_init_packet(&pkt);
729

    
730
        ost->sync_opts += size_out / (osize * enc->channels);
731

    
732
        /* output a pcm frame */
733
        /* determine the size of the coded buffer */
734
        size_out /= osize;
735
        if (coded_bps)
736
            size_out *= coded_bps;
737

    
738
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
739
        ret = avcodec_encode_audio(enc, audio_out, size_out,
740
                                   (short *)buftmp);
741
        if (ret < 0) {
742
            fprintf(stderr, "Audio encoding failed\n");
743
            av_exit(1);
744
        }
745
        audio_size += ret;
746
        pkt.stream_index= ost->index;
747
        pkt.data= audio_out;
748
        pkt.size= ret;
749
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
750
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
751
        pkt.flags |= PKT_FLAG_KEY;
752
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
753
    }
754
}
755

    
756
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
757
{
758
    AVCodecContext *dec;
759
    AVPicture *picture2;
760
    AVPicture picture_tmp;
761
    uint8_t *buf = 0;
762

    
763
    dec = ist->st->codec;
764

    
765
    /* deinterlace : must be done before any resize */
766
    if (do_deinterlace) {
767
        int size;
768

    
769
        /* create temporary picture */
770
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
771
        buf = av_malloc(size);
772
        if (!buf)
773
            return;
774

    
775
        picture2 = &picture_tmp;
776
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
777

    
778
        if(avpicture_deinterlace(picture2, picture,
779
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
780
            /* if error, do not deinterlace */
781
            fprintf(stderr, "Deinterlacing failed\n");
782
            av_free(buf);
783
            buf = NULL;
784
            picture2 = picture;
785
        }
786
    } else {
787
        picture2 = picture;
788
    }
789

    
790
    if (picture != picture2)
791
        *picture = *picture2;
792
    *bufp = buf;
793
}
794

    
795
/* we begin to correct av delay at this threshold */
796
#define AV_DELAY_MAX 0.100
797

    
798
static void do_subtitle_out(AVFormatContext *s,
799
                            AVOutputStream *ost,
800
                            AVInputStream *ist,
801
                            AVSubtitle *sub,
802
                            int64_t pts)
803
{
804
    static uint8_t *subtitle_out = NULL;
805
    int subtitle_out_max_size = 65536;
806
    int subtitle_out_size, nb, i;
807
    AVCodecContext *enc;
808
    AVPacket pkt;
809

    
810
    if (pts == AV_NOPTS_VALUE) {
811
        fprintf(stderr, "Subtitle packets must have a pts\n");
812
        if (exit_on_error)
813
            av_exit(1);
814
        return;
815
    }
816

    
817
    enc = ost->st->codec;
818

    
819
    if (!subtitle_out) {
820
        subtitle_out = av_malloc(subtitle_out_max_size);
821
    }
822

    
823
    /* Note: DVB subtitle need one packet to draw them and one other
824
       packet to clear them */
825
    /* XXX: signal it in the codec context ? */
826
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
827
        nb = 2;
828
    else
829
        nb = 1;
830

    
831
    for(i = 0; i < nb; i++) {
832
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
833
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
834
                                                    subtitle_out_max_size, sub);
835

    
836
        av_init_packet(&pkt);
837
        pkt.stream_index = ost->index;
838
        pkt.data = subtitle_out;
839
        pkt.size = subtitle_out_size;
840
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
841
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
842
            /* XXX: the pts correction is handled here. Maybe handling
843
               it in the codec would be better */
844
            if (i == 0)
845
                pkt.pts += 90 * sub->start_display_time;
846
            else
847
                pkt.pts += 90 * sub->end_display_time;
848
        }
849
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
850
    }
851
}
852

    
853
static int bit_buffer_size= 1024*256;
854
static uint8_t *bit_buffer= NULL;
855

    
856
static void do_video_out(AVFormatContext *s,
857
                         AVOutputStream *ost,
858
                         AVInputStream *ist,
859
                         AVFrame *in_picture,
860
                         int *frame_size)
861
{
862
    int nb_frames, i, ret;
863
    int64_t topBand, bottomBand, leftBand, rightBand;
864
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
865
    AVFrame picture_crop_temp, picture_pad_temp;
866
    AVCodecContext *enc, *dec;
867

    
868
    avcodec_get_frame_defaults(&picture_crop_temp);
869
    avcodec_get_frame_defaults(&picture_pad_temp);
870

    
871
    enc = ost->st->codec;
872
    dec = ist->st->codec;
873

    
874
    /* by default, we output a single frame */
875
    nb_frames = 1;
876

    
877
    *frame_size = 0;
878

    
879
    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
880
        double vdelta;
881
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
882
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
883
        if (vdelta < -1.1)
884
            nb_frames = 0;
885
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
886
            if(vdelta<=-0.6){
887
                nb_frames=0;
888
            }else if(vdelta>0.6)
889
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
890
        }else if (vdelta > 1.1)
891
            nb_frames = lrintf(vdelta);
892
//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);
893
        if (nb_frames == 0){
894
            ++nb_frames_drop;
895
            if (verbose>2)
896
                fprintf(stderr, "*** drop!\n");
897
        }else if (nb_frames > 1) {
898
            nb_frames_dup += nb_frames;
899
            if (verbose>2)
900
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
901
        }
902
    }else
903
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
904

    
905
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
906
    if (nb_frames <= 0)
907
        return;
908

    
909
    if (ost->video_crop) {
910
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
911
            fprintf(stderr, "error cropping picture\n");
912
            if (exit_on_error)
913
                av_exit(1);
914
            return;
915
        }
916
        formatted_picture = &picture_crop_temp;
917
    } else {
918
        formatted_picture = in_picture;
919
    }
920

    
921
    final_picture = formatted_picture;
922
    padding_src = formatted_picture;
923
    resampling_dst = &ost->pict_tmp;
924
    if (ost->video_pad) {
925
        final_picture = &ost->pict_tmp;
926
        if (ost->video_resample) {
927
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
928
                fprintf(stderr, "error padding picture\n");
929
                if (exit_on_error)
930
                    av_exit(1);
931
                return;
932
            }
933
            resampling_dst = &picture_pad_temp;
934
        }
935
    }
936

    
937
    if (ost->video_resample) {
938
        padding_src = NULL;
939
        final_picture = &ost->pict_tmp;
940
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
941
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))) {
942

    
943
            fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d\n", ist->file_index, ist->index, ist->st->codec->width, ist->st->codec->height);
944
            /* keep bands proportional to the frame size */
945
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
946
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
947
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
948
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
949

    
950
            /* sanity check to ensure no bad band sizes sneak in */
951
            assert(topBand    <= INT_MAX && topBand    >= 0);
952
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
953
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
954
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
955

    
956
            ost->topBand    = topBand;
957
            ost->bottomBand = bottomBand;
958
            ost->leftBand   = leftBand;
959
            ost->rightBand  = rightBand;
960

    
961
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
962
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
963

    
964
            /* initialize a new scaler context */
965
            sws_freeContext(ost->img_resample_ctx);
966
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
967
            ost->img_resample_ctx = sws_getContext(
968
                ist->st->codec->width  - (ost->leftBand + ost->rightBand),
969
                ist->st->codec->height - (ost->topBand  + ost->bottomBand),
970
                ist->st->codec->pix_fmt,
971
                ost->st->codec->width  - (ost->padleft  + ost->padright),
972
                ost->st->codec->height - (ost->padtop   + ost->padbottom),
973
                ost->st->codec->pix_fmt,
974
                sws_flags, NULL, NULL, NULL);
975
            if (ost->img_resample_ctx == NULL) {
976
                fprintf(stderr, "Cannot get resampling context\n");
977
                av_exit(1);
978
            }
979
        }
980
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
981
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
982
    }
983

    
984
    if (ost->video_pad) {
985
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
986
                enc->height, enc->width, enc->pix_fmt,
987
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
988
    }
989

    
990
    /* duplicates frame if needed */
991
    for(i=0;i<nb_frames;i++) {
992
        AVPacket pkt;
993
        av_init_packet(&pkt);
994
        pkt.stream_index= ost->index;
995

    
996
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
997
            /* raw pictures are written as AVPicture structure to
998
               avoid any copies. We support temorarily the older
999
               method. */
1000
            AVFrame* old_frame = enc->coded_frame;
1001
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1002
            pkt.data= (uint8_t *)final_picture;
1003
            pkt.size=  sizeof(AVPicture);
1004
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1005
            pkt.flags |= PKT_FLAG_KEY;
1006

    
1007
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1008
            enc->coded_frame = old_frame;
1009
        } else {
1010
            AVFrame big_picture;
1011

    
1012
            big_picture= *final_picture;
1013
            /* better than nothing: use input picture interlaced
1014
               settings */
1015
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1016
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1017
                if(top_field_first == -1)
1018
                    big_picture.top_field_first = in_picture->top_field_first;
1019
                else
1020
                    big_picture.top_field_first = top_field_first;
1021
            }
1022

    
1023
            /* handles sameq here. This is not correct because it may
1024
               not be a global option */
1025
            if (same_quality) {
1026
                big_picture.quality = ist->st->quality;
1027
            }else
1028
                big_picture.quality = ost->st->quality;
1029
            if(!me_threshold)
1030
                big_picture.pict_type = 0;
1031
//            big_picture.pts = AV_NOPTS_VALUE;
1032
            big_picture.pts= ost->sync_opts;
1033
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1034
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1035
            ret = avcodec_encode_video(enc,
1036
                                       bit_buffer, bit_buffer_size,
1037
                                       &big_picture);
1038
            if (ret < 0) {
1039
                fprintf(stderr, "Video encoding failed\n");
1040
                av_exit(1);
1041
            }
1042

    
1043
            if(ret>0){
1044
                pkt.data= bit_buffer;
1045
                pkt.size= ret;
1046
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1047
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1048
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1049
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1050
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1051

    
1052
                if(enc->coded_frame->key_frame)
1053
                    pkt.flags |= PKT_FLAG_KEY;
1054
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1055
                *frame_size = ret;
1056
                video_size += ret;
1057
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1058
                //        enc->frame_number-1, ret, enc->pict_type);
1059
                /* if two pass, output log */
1060
                if (ost->logfile && enc->stats_out) {
1061
                    fprintf(ost->logfile, "%s", enc->stats_out);
1062
                }
1063
            }
1064
        }
1065
        ost->sync_opts++;
1066
        ost->frame_number++;
1067
    }
1068
}
1069

    
1070
static double psnr(double d){
1071
    return -10.0*log(d)/log(10.0);
1072
}
1073

    
1074
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1075
                           int frame_size)
1076
{
1077
    AVCodecContext *enc;
1078
    int frame_number;
1079
    double ti1, bitrate, avg_bitrate;
1080

    
1081
    /* this is executed just the first time do_video_stats is called */
1082
    if (!vstats_file) {
1083
        vstats_file = fopen(vstats_filename, "w");
1084
        if (!vstats_file) {
1085
            perror("fopen");
1086
            av_exit(1);
1087
        }
1088
    }
1089

    
1090
    enc = ost->st->codec;
1091
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1092
        frame_number = ost->frame_number;
1093
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1094
        if (enc->flags&CODEC_FLAG_PSNR)
1095
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1096

    
1097
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1098
        /* compute pts value */
1099
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1100
        if (ti1 < 0.01)
1101
            ti1 = 0.01;
1102

    
1103
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1104
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1105
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1106
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1107
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1108
    }
1109
}
1110

    
1111
static void print_report(AVFormatContext **output_files,
1112
                         AVOutputStream **ost_table, int nb_ostreams,
1113
                         int is_last_report)
1114
{
1115
    char buf[1024];
1116
    AVOutputStream *ost;
1117
    AVFormatContext *oc;
1118
    int64_t total_size;
1119
    AVCodecContext *enc;
1120
    int frame_number, vid, i;
1121
    double bitrate, ti1, pts;
1122
    static int64_t last_time = -1;
1123
    static int qp_histogram[52];
1124

    
1125
    if (!is_last_report) {
1126
        int64_t cur_time;
1127
        /* display the report every 0.5 seconds */
1128
        cur_time = av_gettime();
1129
        if (last_time == -1) {
1130
            last_time = cur_time;
1131
            return;
1132
        }
1133
        if ((cur_time - last_time) < 500000)
1134
            return;
1135
        last_time = cur_time;
1136
    }
1137

    
1138

    
1139
    oc = output_files[0];
1140

    
1141
    total_size = url_fsize(oc->pb);
1142
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1143
        total_size= url_ftell(oc->pb);
1144

    
1145
    buf[0] = '\0';
1146
    ti1 = 1e10;
1147
    vid = 0;
1148
    for(i=0;i<nb_ostreams;i++) {
1149
        ost = ost_table[i];
1150
        enc = ost->st->codec;
1151
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1152
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1153
                     !ost->st->stream_copy ?
1154
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1155
        }
1156
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1157
            float t = (av_gettime()-timer_start) / 1000000.0;
1158

    
1159
            frame_number = ost->frame_number;
1160
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1161
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1162
                     !ost->st->stream_copy ?
1163
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1164
            if(is_last_report)
1165
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1166
            if(qp_hist){
1167
                int j;
1168
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1169
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1170
                    qp_histogram[qp]++;
1171
                for(j=0; j<32; j++)
1172
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1173
            }
1174
            if (enc->flags&CODEC_FLAG_PSNR){
1175
                int j;
1176
                double error, error_sum=0;
1177
                double scale, scale_sum=0;
1178
                char type[3]= {'Y','U','V'};
1179
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1180
                for(j=0; j<3; j++){
1181
                    if(is_last_report){
1182
                        error= enc->error[j];
1183
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1184
                    }else{
1185
                        error= enc->coded_frame->error[j];
1186
                        scale= enc->width*enc->height*255.0*255.0;
1187
                    }
1188
                    if(j) scale/=4;
1189
                    error_sum += error;
1190
                    scale_sum += scale;
1191
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1192
                }
1193
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1194
            }
1195
            vid = 1;
1196
        }
1197
        /* compute min output value */
1198
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1199
        if ((pts < ti1) && (pts > 0))
1200
            ti1 = pts;
1201
    }
1202
    if (ti1 < 0.01)
1203
        ti1 = 0.01;
1204

    
1205
    if (verbose || is_last_report) {
1206
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1207

    
1208
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1209
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1210
            (double)total_size / 1024, ti1, bitrate);
1211

    
1212
        if (verbose > 1)
1213
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1214
                  nb_frames_dup, nb_frames_drop);
1215

    
1216
        if (verbose >= 0)
1217
            fprintf(stderr, "%s    \r", buf);
1218

    
1219
        fflush(stderr);
1220
    }
1221

    
1222
    if (is_last_report && verbose >= 0){
1223
        int64_t raw= audio_size + video_size + extra_size;
1224
        fprintf(stderr, "\n");
1225
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1226
                video_size/1024.0,
1227
                audio_size/1024.0,
1228
                extra_size/1024.0,
1229
                100.0*(total_size - raw)/raw
1230
        );
1231
    }
1232
}
1233

    
1234
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1235
static int output_packet(AVInputStream *ist, int ist_index,
1236
                         AVOutputStream **ost_table, int nb_ostreams,
1237
                         const AVPacket *pkt)
1238
{
1239
    AVFormatContext *os;
1240
    AVOutputStream *ost;
1241
    int ret, i;
1242
    uint8_t *data_buf;
1243
    int data_size, got_picture;
1244
    AVFrame picture;
1245
    void *buffer_to_free;
1246
    static unsigned int samples_size= 0;
1247
    AVSubtitle subtitle, *subtitle_to_free;
1248
    int got_subtitle;
1249
    AVPacket avpkt;
1250

    
1251
    if(ist->next_pts == AV_NOPTS_VALUE)
1252
        ist->next_pts= ist->pts;
1253

    
1254
    if (pkt == NULL) {
1255
        /* EOF handling */
1256
        av_init_packet(&avpkt);
1257
        avpkt.data = NULL;
1258
        avpkt.size = 0;
1259
        goto handle_eof;
1260
    } else {
1261
        avpkt = *pkt;
1262
    }
1263

    
1264
    if(pkt->dts != AV_NOPTS_VALUE)
1265
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1266

    
1267
    //while we have more to decode or while the decoder did output something on EOF
1268
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1269
    handle_eof:
1270
        ist->pts= ist->next_pts;
1271

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

    
1275
        /* decode the packet if needed */
1276
        data_buf = NULL; /* fail safe */
1277
        data_size = 0;
1278
        subtitle_to_free = NULL;
1279
        if (ist->decoding_needed) {
1280
            switch(ist->st->codec->codec_type) {
1281
            case CODEC_TYPE_AUDIO:{
1282
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1283
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1284
                    av_free(samples);
1285
                    samples= av_malloc(samples_size);
1286
                }
1287
                data_size= samples_size;
1288
                    /* XXX: could avoid copy if PCM 16 bits with same
1289
                       endianness as CPU */
1290
                ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size,
1291
                                            &avpkt);
1292
                if (ret < 0)
1293
                    goto fail_decode;
1294
                avpkt.data += ret;
1295
                avpkt.size -= ret;
1296
                /* Some bug in mpeg audio decoder gives */
1297
                /* data_size < 0, it seems they are overflows */
1298
                if (data_size <= 0) {
1299
                    /* no audio frame */
1300
                    continue;
1301
                }
1302
                data_buf = (uint8_t *)samples;
1303
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1304
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1305
                break;}
1306
            case CODEC_TYPE_VIDEO:
1307
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1308
                    /* XXX: allocate picture correctly */
1309
                    avcodec_get_frame_defaults(&picture);
1310

    
1311
                    ret = avcodec_decode_video2(ist->st->codec,
1312
                                                &picture, &got_picture, &avpkt);
1313
                    ist->st->quality= picture.quality;
1314
                    if (ret < 0)
1315
                        goto fail_decode;
1316
                    if (!got_picture) {
1317
                        /* no picture yet */
1318
                        goto discard_packet;
1319
                    }
1320
                    if (ist->st->codec->time_base.num != 0) {
1321
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1322
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1323
                                          ist->st->codec->time_base.num * ticks) /
1324
                            ist->st->codec->time_base.den;
1325
                    }
1326
                    avpkt.size = 0;
1327
                    break;
1328
            case CODEC_TYPE_SUBTITLE:
1329
                ret = avcodec_decode_subtitle2(ist->st->codec,
1330
                                               &subtitle, &got_subtitle, &avpkt);
1331
                if (ret < 0)
1332
                    goto fail_decode;
1333
                if (!got_subtitle) {
1334
                    goto discard_packet;
1335
                }
1336
                subtitle_to_free = &subtitle;
1337
                avpkt.size = 0;
1338
                break;
1339
            default:
1340
                goto fail_decode;
1341
            }
1342
        } else {
1343
            switch(ist->st->codec->codec_type) {
1344
            case CODEC_TYPE_AUDIO:
1345
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1346
                    ist->st->codec->sample_rate;
1347
                break;
1348
            case CODEC_TYPE_VIDEO:
1349
                if (ist->st->codec->time_base.num != 0) {
1350
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1351
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1352
                                      ist->st->codec->time_base.num * ticks) /
1353
                        ist->st->codec->time_base.den;
1354
                }
1355
                break;
1356
            }
1357
            data_buf = avpkt.data;
1358
            data_size = avpkt.size;
1359
            ret = avpkt.size;
1360
            avpkt.size = 0;
1361
        }
1362

    
1363
        buffer_to_free = NULL;
1364
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1365
            pre_process_video_frame(ist, (AVPicture *)&picture,
1366
                                    &buffer_to_free);
1367
        }
1368

    
1369
        // preprocess audio (volume)
1370
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1371
            if (audio_volume != 256) {
1372
                short *volp;
1373
                volp = samples;
1374
                for(i=0;i<(data_size / sizeof(short));i++) {
1375
                    int v = ((*volp) * audio_volume + 128) >> 8;
1376
                    if (v < -32768) v = -32768;
1377
                    if (v >  32767) v = 32767;
1378
                    *volp++ = v;
1379
                }
1380
            }
1381
        }
1382

    
1383
        /* frame rate emulation */
1384
        if (rate_emu) {
1385
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1386
            int64_t now = av_gettime() - ist->start;
1387
            if (pts > now)
1388
                usleep(pts - now);
1389
        }
1390

    
1391
        /* if output time reached then transcode raw format,
1392
           encode packets and output them */
1393
        if (start_time == 0 || ist->pts >= start_time)
1394
            for(i=0;i<nb_ostreams;i++) {
1395
                int frame_size;
1396

    
1397
                ost = ost_table[i];
1398
                if (ost->source_index == ist_index) {
1399
                    os = output_files[ost->file_index];
1400

    
1401
#if 0
1402
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1403
                           (double)pkt->pts / AV_TIME_BASE,
1404
                           ((double)ist->pts / AV_TIME_BASE) -
1405
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1406
#endif
1407
                    /* set the input output pts pairs */
1408
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1409

    
1410
                    if (ost->encoding_needed) {
1411
                        switch(ost->st->codec->codec_type) {
1412
                        case CODEC_TYPE_AUDIO:
1413
                            do_audio_out(os, ost, ist, data_buf, data_size);
1414
                            break;
1415
                        case CODEC_TYPE_VIDEO:
1416
                            do_video_out(os, ost, ist, &picture, &frame_size);
1417
                            if (vstats_filename && frame_size)
1418
                                do_video_stats(os, ost, frame_size);
1419
                            break;
1420
                        case CODEC_TYPE_SUBTITLE:
1421
                            do_subtitle_out(os, ost, ist, &subtitle,
1422
                                            pkt->pts);
1423
                            break;
1424
                        default:
1425
                            abort();
1426
                        }
1427
                    } else {
1428
                        AVFrame avframe; //FIXME/XXX remove this
1429
                        AVPacket opkt;
1430
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1431

    
1432
                        av_init_packet(&opkt);
1433

    
1434
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1435
                            continue;
1436

    
1437
                        /* no reencoding needed : output the packet directly */
1438
                        /* force the input stream PTS */
1439

    
1440
                        avcodec_get_frame_defaults(&avframe);
1441
                        ost->st->codec->coded_frame= &avframe;
1442
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1443

    
1444
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1445
                            audio_size += data_size;
1446
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1447
                            video_size += data_size;
1448
                            ost->sync_opts++;
1449
                        }
1450

    
1451
                        opkt.stream_index= ost->index;
1452
                        if(pkt->pts != AV_NOPTS_VALUE)
1453
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1454
                        else
1455
                            opkt.pts= AV_NOPTS_VALUE;
1456

    
1457
                        if (pkt->dts == AV_NOPTS_VALUE)
1458
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1459
                        else
1460
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1461
                        opkt.dts -= ost_tb_start_time;
1462

    
1463
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1464
                        opkt.flags= pkt->flags;
1465

    
1466
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1467
                        if(ost->st->codec->codec_id != CODEC_ID_H264) {
1468
                        if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1469
                            opkt.destruct= av_destruct_packet;
1470
                        } else {
1471
                            opkt.data = data_buf;
1472
                            opkt.size = data_size;
1473
                        }
1474

    
1475
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1476
                        ost->st->codec->frame_number++;
1477
                        ost->frame_number++;
1478
                        av_free_packet(&opkt);
1479
                    }
1480
                }
1481
            }
1482
        av_free(buffer_to_free);
1483
        /* XXX: allocate the subtitles in the codec ? */
1484
        if (subtitle_to_free) {
1485
            if (subtitle_to_free->rects != NULL) {
1486
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1487
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1488
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1489
                    av_freep(&subtitle_to_free->rects[i]);
1490
                }
1491
                av_freep(&subtitle_to_free->rects);
1492
            }
1493
            subtitle_to_free->num_rects = 0;
1494
            subtitle_to_free = NULL;
1495
        }
1496
    }
1497
 discard_packet:
1498
    if (pkt == NULL) {
1499
        /* EOF handling */
1500

    
1501
        for(i=0;i<nb_ostreams;i++) {
1502
            ost = ost_table[i];
1503
            if (ost->source_index == ist_index) {
1504
                AVCodecContext *enc= ost->st->codec;
1505
                os = output_files[ost->file_index];
1506

    
1507
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1508
                    continue;
1509
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1510
                    continue;
1511

    
1512
                if (ost->encoding_needed) {
1513
                    for(;;) {
1514
                        AVPacket pkt;
1515
                        int fifo_bytes;
1516
                        av_init_packet(&pkt);
1517
                        pkt.stream_index= ost->index;
1518

    
1519
                        switch(ost->st->codec->codec_type) {
1520
                        case CODEC_TYPE_AUDIO:
1521
                            fifo_bytes = av_fifo_size(ost->fifo);
1522
                            ret = 0;
1523
                            /* encode any samples remaining in fifo */
1524
                            if (fifo_bytes > 0) {
1525
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1526
                                int fs_tmp = enc->frame_size;
1527

    
1528
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1529
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1530
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1531
                                } else { /* pad */
1532
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1533
                                    if (samples_size < frame_bytes)
1534
                                        av_exit(1);
1535
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1536
                                }
1537

    
1538
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1539
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1540
                                                          ost->st->time_base.num, enc->sample_rate);
1541
                                enc->frame_size = fs_tmp;
1542
                            }
1543
                            if(ret <= 0) {
1544
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1545
                            }
1546
                            if (ret < 0) {
1547
                                fprintf(stderr, "Audio encoding failed\n");
1548
                                av_exit(1);
1549
                            }
1550
                            audio_size += ret;
1551
                            pkt.flags |= PKT_FLAG_KEY;
1552
                            break;
1553
                        case CODEC_TYPE_VIDEO:
1554
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1555
                            if (ret < 0) {
1556
                                fprintf(stderr, "Video encoding failed\n");
1557
                                av_exit(1);
1558
                            }
1559
                            video_size += ret;
1560
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1561
                                pkt.flags |= PKT_FLAG_KEY;
1562
                            if (ost->logfile && enc->stats_out) {
1563
                                fprintf(ost->logfile, "%s", enc->stats_out);
1564
                            }
1565
                            break;
1566
                        default:
1567
                            ret=-1;
1568
                        }
1569

    
1570
                        if(ret<=0)
1571
                            break;
1572
                        pkt.data= bit_buffer;
1573
                        pkt.size= ret;
1574
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1575
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1576
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1577
                    }
1578
                }
1579
            }
1580
        }
1581
    }
1582

    
1583
    return 0;
1584
 fail_decode:
1585
    return -1;
1586
}
1587

    
1588
static void print_sdp(AVFormatContext **avc, int n)
1589
{
1590
    char sdp[2048];
1591

    
1592
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1593
    printf("SDP:\n%s\n", sdp);
1594
    fflush(stdout);
1595
}
1596

    
1597
static int stream_index_from_inputs(AVFormatContext **input_files,
1598
                                    int nb_input_files,
1599
                                    AVInputFile *file_table,
1600
                                    AVInputStream **ist_table,
1601
                                    enum CodecType type,
1602
                                    int programid)
1603
{
1604
    int p, q, z;
1605
    for(z=0; z<nb_input_files; z++) {
1606
        AVFormatContext *ic = input_files[z];
1607
        for(p=0; p<ic->nb_programs; p++) {
1608
            AVProgram *program = ic->programs[p];
1609
            if(program->id != programid)
1610
                continue;
1611
            for(q=0; q<program->nb_stream_indexes; q++) {
1612
                int sidx = program->stream_index[q];
1613
                int ris = file_table[z].ist_index + sidx;
1614
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1615
                    return ris;
1616
            }
1617
        }
1618
    }
1619

    
1620
    return -1;
1621
}
1622

    
1623
/*
1624
 * The following code is the main loop of the file converter
1625
 */
1626
static int av_encode(AVFormatContext **output_files,
1627
                     int nb_output_files,
1628
                     AVFormatContext **input_files,
1629
                     int nb_input_files,
1630
                     AVStreamMap *stream_maps, int nb_stream_maps)
1631
{
1632
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1633
    AVFormatContext *is, *os;
1634
    AVCodecContext *codec, *icodec;
1635
    AVOutputStream *ost, **ost_table = NULL;
1636
    AVInputStream *ist, **ist_table = NULL;
1637
    AVInputFile *file_table;
1638
    char error[1024];
1639
    int key;
1640
    int want_sdp = 1;
1641
    uint8_t no_packet[MAX_FILES]={0};
1642
    int no_packet_count=0;
1643

    
1644
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1645
    if (!file_table)
1646
        goto fail;
1647

    
1648
    /* input stream init */
1649
    j = 0;
1650
    for(i=0;i<nb_input_files;i++) {
1651
        is = input_files[i];
1652
        file_table[i].ist_index = j;
1653
        file_table[i].nb_streams = is->nb_streams;
1654
        j += is->nb_streams;
1655
    }
1656
    nb_istreams = j;
1657

    
1658
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1659
    if (!ist_table)
1660
        goto fail;
1661

    
1662
    for(i=0;i<nb_istreams;i++) {
1663
        ist = av_mallocz(sizeof(AVInputStream));
1664
        if (!ist)
1665
            goto fail;
1666
        ist_table[i] = ist;
1667
    }
1668
    j = 0;
1669
    for(i=0;i<nb_input_files;i++) {
1670
        is = input_files[i];
1671
        for(k=0;k<is->nb_streams;k++) {
1672
            ist = ist_table[j++];
1673
            ist->st = is->streams[k];
1674
            ist->file_index = i;
1675
            ist->index = k;
1676
            ist->discard = 1; /* the stream is discarded by default
1677
                                 (changed later) */
1678

    
1679
            if (rate_emu) {
1680
                ist->start = av_gettime();
1681
            }
1682
        }
1683
    }
1684

    
1685
    /* output stream init */
1686
    nb_ostreams = 0;
1687
    for(i=0;i<nb_output_files;i++) {
1688
        os = output_files[i];
1689
        if (!os->nb_streams) {
1690
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1691
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1692
            av_exit(1);
1693
        }
1694
        nb_ostreams += os->nb_streams;
1695
    }
1696
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1697
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1698
        av_exit(1);
1699
    }
1700

    
1701
    /* Sanity check the mapping args -- do the input files & streams exist? */
1702
    for(i=0;i<nb_stream_maps;i++) {
1703
        int fi = stream_maps[i].file_index;
1704
        int si = stream_maps[i].stream_index;
1705

    
1706
        if (fi < 0 || fi > nb_input_files - 1 ||
1707
            si < 0 || si > file_table[fi].nb_streams - 1) {
1708
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1709
            av_exit(1);
1710
        }
1711
        fi = stream_maps[i].sync_file_index;
1712
        si = stream_maps[i].sync_stream_index;
1713
        if (fi < 0 || fi > nb_input_files - 1 ||
1714
            si < 0 || si > file_table[fi].nb_streams - 1) {
1715
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1716
            av_exit(1);
1717
        }
1718
    }
1719

    
1720
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1721
    if (!ost_table)
1722
        goto fail;
1723
    for(i=0;i<nb_ostreams;i++) {
1724
        ost = av_mallocz(sizeof(AVOutputStream));
1725
        if (!ost)
1726
            goto fail;
1727
        ost_table[i] = ost;
1728
    }
1729

    
1730
    n = 0;
1731
    for(k=0;k<nb_output_files;k++) {
1732
        os = output_files[k];
1733
        for(i=0;i<os->nb_streams;i++,n++) {
1734
            int found;
1735
            ost = ost_table[n];
1736
            ost->file_index = k;
1737
            ost->index = i;
1738
            ost->st = os->streams[i];
1739
            if (nb_stream_maps > 0) {
1740
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1741
                    stream_maps[n].stream_index;
1742

    
1743
                /* Sanity check that the stream types match */
1744
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1745
                    int i= ost->file_index;
1746
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1747
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1748
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1749
                        ost->file_index, ost->index);
1750
                    av_exit(1);
1751
                }
1752

    
1753
            } else {
1754
                if(opt_programid) {
1755
                    found = 0;
1756
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1757
                    if(j != -1) {
1758
                        ost->source_index = j;
1759
                        found = 1;
1760
                    }
1761
                } else {
1762
                    /* get corresponding input stream index : we select the first one with the right type */
1763
                    found = 0;
1764
                    for(j=0;j<nb_istreams;j++) {
1765
                        ist = ist_table[j];
1766
                        if (ist->discard &&
1767
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1768
                            ost->source_index = j;
1769
                            found = 1;
1770
                            break;
1771
                        }
1772
                    }
1773
                }
1774

    
1775
                if (!found) {
1776
                    if(! opt_programid) {
1777
                        /* try again and reuse existing stream */
1778
                        for(j=0;j<nb_istreams;j++) {
1779
                            ist = ist_table[j];
1780
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1781
                                ost->source_index = j;
1782
                                found = 1;
1783
                            }
1784
                        }
1785
                    }
1786
                    if (!found) {
1787
                        int i= ost->file_index;
1788
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1789
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1790
                                ost->file_index, ost->index);
1791
                        av_exit(1);
1792
                    }
1793
                }
1794
            }
1795
            ist = ist_table[ost->source_index];
1796
            ist->discard = 0;
1797
            ost->sync_ist = (nb_stream_maps > 0) ?
1798
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1799
                         stream_maps[n].sync_stream_index] : ist;
1800
        }
1801
    }
1802

    
1803
    /* for each output stream, we compute the right encoding parameters */
1804
    for(i=0;i<nb_ostreams;i++) {
1805
        AVMetadataTag *lang;
1806
        ost = ost_table[i];
1807
        os = output_files[ost->file_index];
1808
        ist = ist_table[ost->source_index];
1809

    
1810
        codec = ost->st->codec;
1811
        icodec = ist->st->codec;
1812

    
1813
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1814
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1815
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1816

    
1817
        ost->st->disposition = ist->st->disposition;
1818
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1819
        codec->chroma_sample_location = icodec->chroma_sample_location;
1820

    
1821
        if (ost->st->stream_copy) {
1822
            /* if stream_copy is selected, no need to decode or encode */
1823
            codec->codec_id = icodec->codec_id;
1824
            codec->codec_type = icodec->codec_type;
1825

    
1826
            if(!codec->codec_tag){
1827
                if(   !os->oformat->codec_tag
1828
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1829
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1830
                    codec->codec_tag = icodec->codec_tag;
1831
            }
1832

    
1833
            codec->bit_rate = icodec->bit_rate;
1834
            codec->extradata= icodec->extradata;
1835
            codec->extradata_size= icodec->extradata_size;
1836
            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){
1837
                codec->time_base = icodec->time_base;
1838
                codec->time_base.num *= icodec->ticks_per_frame;
1839
            }else
1840
                codec->time_base = ist->st->time_base;
1841
            switch(codec->codec_type) {
1842
            case CODEC_TYPE_AUDIO:
1843
                if(audio_volume != 256) {
1844
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1845
                    av_exit(1);
1846
                }
1847
                codec->channel_layout = icodec->channel_layout;
1848
                codec->sample_rate = icodec->sample_rate;
1849
                codec->channels = icodec->channels;
1850
                codec->frame_size = icodec->frame_size;
1851
                codec->block_align= icodec->block_align;
1852
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1853
                    codec->block_align= 0;
1854
                if(codec->codec_id == CODEC_ID_AC3)
1855
                    codec->block_align= 0;
1856
                break;
1857
            case CODEC_TYPE_VIDEO:
1858
                codec->pix_fmt = icodec->pix_fmt;
1859
                codec->width = icodec->width;
1860
                codec->height = icodec->height;
1861
                codec->has_b_frames = icodec->has_b_frames;
1862
                break;
1863
            case CODEC_TYPE_SUBTITLE:
1864
                codec->width = icodec->width;
1865
                codec->height = icodec->height;
1866
                break;
1867
            default:
1868
                abort();
1869
            }
1870
        } else {
1871
            switch(codec->codec_type) {
1872
            case CODEC_TYPE_AUDIO:
1873
                ost->fifo= av_fifo_alloc(1024);
1874
                if(!ost->fifo)
1875
                    goto fail;
1876
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1877
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1878
                icodec->request_channels = codec->channels;
1879
                ist->decoding_needed = 1;
1880
                ost->encoding_needed = 1;
1881
                break;
1882
            case CODEC_TYPE_VIDEO:
1883
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1884
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1885
                    av_exit(1);
1886
                }
1887
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1888
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1889
                ost->video_resample = ((codec->width != icodec->width -
1890
                                (frame_leftBand + frame_rightBand) +
1891
                                (frame_padleft + frame_padright)) ||
1892
                        (codec->height != icodec->height -
1893
                                (frame_topBand  + frame_bottomBand) +
1894
                                (frame_padtop + frame_padbottom)) ||
1895
                        (codec->pix_fmt != icodec->pix_fmt));
1896
                if (ost->video_crop) {
1897
                    ost->topBand    = ost->original_topBand    = frame_topBand;
1898
                    ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
1899
                    ost->leftBand   = ost->original_leftBand   = frame_leftBand;
1900
                    ost->rightBand  = ost->original_rightBand  = frame_rightBand;
1901
                }
1902
                if (ost->video_pad) {
1903
                    ost->padtop = frame_padtop;
1904
                    ost->padleft = frame_padleft;
1905
                    ost->padbottom = frame_padbottom;
1906
                    ost->padright = frame_padright;
1907
                    if (!ost->video_resample) {
1908
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1909
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1910
                                         codec->width, codec->height))
1911
                            goto fail;
1912
                    }
1913
                }
1914
                if (ost->video_resample) {
1915
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1916
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1917
                                         codec->width, codec->height)) {
1918
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1919
                        av_exit(1);
1920
                    }
1921
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1922
                    ost->img_resample_ctx = sws_getContext(
1923
                            icodec->width - (frame_leftBand + frame_rightBand),
1924
                            icodec->height - (frame_topBand + frame_bottomBand),
1925
                            icodec->pix_fmt,
1926
                            codec->width - (frame_padleft + frame_padright),
1927
                            codec->height - (frame_padtop + frame_padbottom),
1928
                            codec->pix_fmt,
1929
                            sws_flags, NULL, NULL, NULL);
1930
                    if (ost->img_resample_ctx == NULL) {
1931
                        fprintf(stderr, "Cannot get resampling context\n");
1932
                        av_exit(1);
1933
                    }
1934

    
1935
                    ost->original_height = icodec->height;
1936
                    ost->original_width  = icodec->width;
1937

    
1938
                    ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
1939
                    ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
1940
                    codec->bits_per_raw_sample= 0;
1941
                }
1942
                ost->encoding_needed = 1;
1943
                ist->decoding_needed = 1;
1944
                break;
1945
            case CODEC_TYPE_SUBTITLE:
1946
                ost->encoding_needed = 1;
1947
                ist->decoding_needed = 1;
1948
                break;
1949
            default:
1950
                abort();
1951
                break;
1952
            }
1953
            /* two pass mode */
1954
            if (ost->encoding_needed &&
1955
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1956
                char logfilename[1024];
1957
                FILE *f;
1958
                int size;
1959
                char *logbuffer;
1960

    
1961
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1962
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1963
                         i);
1964
                if (codec->flags & CODEC_FLAG_PASS1) {
1965
                    f = fopen(logfilename, "w");
1966
                    if (!f) {
1967
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1968
                        av_exit(1);
1969
                    }
1970
                    ost->logfile = f;
1971
                } else {
1972
                    /* read the log file */
1973
                    f = fopen(logfilename, "r");
1974
                    if (!f) {
1975
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1976
                        av_exit(1);
1977
                    }
1978
                    fseek(f, 0, SEEK_END);
1979
                    size = ftell(f);
1980
                    fseek(f, 0, SEEK_SET);
1981
                    logbuffer = av_malloc(size + 1);
1982
                    if (!logbuffer) {
1983
                        fprintf(stderr, "Could not allocate log buffer\n");
1984
                        av_exit(1);
1985
                    }
1986
                    size = fread(logbuffer, 1, size, f);
1987
                    fclose(f);
1988
                    logbuffer[size] = '\0';
1989
                    codec->stats_in = logbuffer;
1990
                }
1991
            }
1992
        }
1993
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1994
            int size= codec->width * codec->height;
1995
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1996
        }
1997
    }
1998

    
1999
    if (!bit_buffer)
2000
        bit_buffer = av_malloc(bit_buffer_size);
2001
    if (!bit_buffer) {
2002
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2003
                bit_buffer_size);
2004
        ret = AVERROR(ENOMEM);
2005
        goto fail;
2006
    }
2007

    
2008
    /* open each encoder */
2009
    for(i=0;i<nb_ostreams;i++) {
2010
        ost = ost_table[i];
2011
        if (ost->encoding_needed) {
2012
            AVCodec *codec = output_codecs[i];
2013
            if (!codec)
2014
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2015
            if (!codec) {
2016
                snprintf(error, sizeof(error), "Unsupported codec for output stream #%d.%d",
2017
                        ost->file_index, ost->index);
2018
                ret = AVERROR(EINVAL);
2019
                goto dump_format;
2020
            }
2021
            if (avcodec_open(ost->st->codec, codec) < 0) {
2022
                snprintf(error, sizeof(error), "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2023
                        ost->file_index, ost->index);
2024
                ret = AVERROR(EINVAL);
2025
                goto dump_format;
2026
            }
2027
            extra_size += ost->st->codec->extradata_size;
2028
        }
2029
    }
2030

    
2031
    /* open each decoder */
2032
    for(i=0;i<nb_istreams;i++) {
2033
        ist = ist_table[i];
2034
        if (ist->decoding_needed) {
2035
            AVCodec *codec = input_codecs[i];
2036
            if (!codec)
2037
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2038
            if (!codec) {
2039
                snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
2040
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2041
                ret = AVERROR(EINVAL);
2042
                goto dump_format;
2043
            }
2044
            if (avcodec_open(ist->st->codec, codec) < 0) {
2045
                snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
2046
                        ist->file_index, ist->index);
2047
                ret = AVERROR(EINVAL);
2048
                goto dump_format;
2049
            }
2050
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2051
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2052
        }
2053
    }
2054

    
2055
    /* init pts */
2056
    for(i=0;i<nb_istreams;i++) {
2057
        ist = ist_table[i];
2058
        ist->pts = 0;
2059
        ist->next_pts = AV_NOPTS_VALUE;
2060
        ist->is_start = 1;
2061
    }
2062

    
2063
    /* set meta data information from input file if required */
2064
    for (i=0;i<nb_meta_data_maps;i++) {
2065
        AVFormatContext *out_file;
2066
        AVFormatContext *in_file;
2067
        AVMetadataTag *mtag;
2068

    
2069
        int out_file_index = meta_data_maps[i].out_file;
2070
        int in_file_index = meta_data_maps[i].in_file;
2071
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2072
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2073
                     out_file_index, out_file_index, in_file_index);
2074
            ret = AVERROR(EINVAL);
2075
            goto dump_format;
2076
        }
2077
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2078
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2079
                     in_file_index, out_file_index, in_file_index);
2080
            ret = AVERROR(EINVAL);
2081
            goto dump_format;
2082
        }
2083

    
2084
        out_file = output_files[out_file_index];
2085
        in_file = input_files[in_file_index];
2086

    
2087

    
2088
        mtag=NULL;
2089
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2090
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2091
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2092
                                    in_file->iformat->metadata_conv);
2093
    }
2094

    
2095
    /* open files and write file headers */
2096
    for(i=0;i<nb_output_files;i++) {
2097
        os = output_files[i];
2098
        if (av_write_header(os) < 0) {
2099
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2100
            ret = AVERROR(EINVAL);
2101
            goto dump_format;
2102
        }
2103
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2104
            want_sdp = 0;
2105
        }
2106
    }
2107

    
2108
 dump_format:
2109
    /* dump the file output parameters - cannot be done before in case
2110
       of stream copy */
2111
    for(i=0;i<nb_output_files;i++) {
2112
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2113
    }
2114

    
2115
    /* dump the stream mapping */
2116
    if (verbose >= 0) {
2117
        fprintf(stderr, "Stream mapping:\n");
2118
        for(i=0;i<nb_ostreams;i++) {
2119
            ost = ost_table[i];
2120
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2121
                    ist_table[ost->source_index]->file_index,
2122
                    ist_table[ost->source_index]->index,
2123
                    ost->file_index,
2124
                    ost->index);
2125
            if (ost->sync_ist != ist_table[ost->source_index])
2126
                fprintf(stderr, " [sync #%d.%d]",
2127
                        ost->sync_ist->file_index,
2128
                        ost->sync_ist->index);
2129
            fprintf(stderr, "\n");
2130
        }
2131
    }
2132

    
2133
    if (ret) {
2134
        fprintf(stderr, "%s\n", error);
2135
        goto fail;
2136
    }
2137

    
2138
    if (want_sdp) {
2139
        print_sdp(output_files, nb_output_files);
2140
    }
2141

    
2142
    if (!using_stdin && verbose >= 0) {
2143
        fprintf(stderr, "Press [q] to stop encoding\n");
2144
        url_set_interrupt_cb(decode_interrupt_cb);
2145
    }
2146
    term_init();
2147

    
2148
    timer_start = av_gettime();
2149

    
2150
    for(; received_sigterm == 0;) {
2151
        int file_index, ist_index;
2152
        AVPacket pkt;
2153
        double ipts_min;
2154
        double opts_min;
2155

    
2156
    redo:
2157
        ipts_min= 1e100;
2158
        opts_min= 1e100;
2159
        /* if 'q' pressed, exits */
2160
        if (!using_stdin) {
2161
            if (q_pressed)
2162
                break;
2163
            /* read_key() returns 0 on EOF */
2164
            key = read_key();
2165
            if (key == 'q')
2166
                break;
2167
        }
2168

    
2169
        /* select the stream that we must read now by looking at the
2170
           smallest output pts */
2171
        file_index = -1;
2172
        for(i=0;i<nb_ostreams;i++) {
2173
            double ipts, opts;
2174
            ost = ost_table[i];
2175
            os = output_files[ost->file_index];
2176
            ist = ist_table[ost->source_index];
2177
            if(no_packet[ist->file_index])
2178
                continue;
2179
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2180
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2181
            else
2182
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2183
            ipts = (double)ist->pts;
2184
            if (!file_table[ist->file_index].eof_reached){
2185
                if(ipts < ipts_min) {
2186
                    ipts_min = ipts;
2187
                    if(input_sync ) file_index = ist->file_index;
2188
                }
2189
                if(opts < opts_min) {
2190
                    opts_min = opts;
2191
                    if(!input_sync) file_index = ist->file_index;
2192
                }
2193
            }
2194
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2195
                file_index= -1;
2196
                break;
2197
            }
2198
        }
2199
        /* if none, if is finished */
2200
        if (file_index < 0) {
2201
            if(no_packet_count){
2202
                no_packet_count=0;
2203
                memset(no_packet, 0, sizeof(no_packet));
2204
                usleep(10000);
2205
                continue;
2206
            }
2207
            break;
2208
        }
2209

    
2210
        /* finish if recording time exhausted */
2211
        if (opts_min >= (recording_time / 1000000.0))
2212
            break;
2213

    
2214
        /* finish if limit size exhausted */
2215
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2216
            break;
2217

    
2218
        /* read a frame from it and output it in the fifo */
2219
        is = input_files[file_index];
2220
        ret= av_read_frame(is, &pkt);
2221
        if(ret == AVERROR(EAGAIN)){
2222
            no_packet[file_index]=1;
2223
            no_packet_count++;
2224
            continue;
2225
        }
2226
        if (ret < 0) {
2227
            file_table[file_index].eof_reached = 1;
2228
            if (opt_shortest)
2229
                break;
2230
            else
2231
                continue;
2232
        }
2233

    
2234
        no_packet_count=0;
2235
        memset(no_packet, 0, sizeof(no_packet));
2236

    
2237
        if (do_pkt_dump) {
2238
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2239
        }
2240
        /* the following test is needed in case new streams appear
2241
           dynamically in stream : we ignore them */
2242
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2243
            goto discard_packet;
2244
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2245
        ist = ist_table[ist_index];
2246
        if (ist->discard)
2247
            goto discard_packet;
2248

    
2249
        if (pkt.dts != AV_NOPTS_VALUE)
2250
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2251
        if (pkt.pts != AV_NOPTS_VALUE)
2252
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2253

    
2254
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2255
            if(pkt.pts != AV_NOPTS_VALUE)
2256
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2257
            if(pkt.dts != AV_NOPTS_VALUE)
2258
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2259
        }
2260

    
2261
//        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);
2262
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2263
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2264
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2265
            int64_t delta= pkt_dts - ist->next_pts;
2266
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2267
                input_files_ts_offset[ist->file_index]-= delta;
2268
                if (verbose > 2)
2269
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2270
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2271
                if(pkt.pts != AV_NOPTS_VALUE)
2272
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2273
            }
2274
        }
2275

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

    
2279
            if (verbose >= 0)
2280
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2281
                        ist->file_index, ist->index);
2282
            if (exit_on_error)
2283
                av_exit(1);
2284
            av_free_packet(&pkt);
2285
            goto redo;
2286
        }
2287

    
2288
    discard_packet:
2289
        av_free_packet(&pkt);
2290

    
2291
        /* dump report by using the output first video and audio streams */
2292
        print_report(output_files, ost_table, nb_ostreams, 0);
2293
    }
2294

    
2295
    /* at the end of stream, we must flush the decoder buffers */
2296
    for(i=0;i<nb_istreams;i++) {
2297
        ist = ist_table[i];
2298
        if (ist->decoding_needed) {
2299
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2300
        }
2301
    }
2302

    
2303
    term_exit();
2304

    
2305
    /* write the trailer if needed and close file */
2306
    for(i=0;i<nb_output_files;i++) {
2307
        os = output_files[i];
2308
        av_write_trailer(os);
2309
    }
2310

    
2311
    /* dump report by using the first video and audio streams */
2312
    print_report(output_files, ost_table, nb_ostreams, 1);
2313

    
2314
    /* close each encoder */
2315
    for(i=0;i<nb_ostreams;i++) {
2316
        ost = ost_table[i];
2317
        if (ost->encoding_needed) {
2318
            av_freep(&ost->st->codec->stats_in);
2319
            avcodec_close(ost->st->codec);
2320
        }
2321
    }
2322

    
2323
    /* close each decoder */
2324
    for(i=0;i<nb_istreams;i++) {
2325
        ist = ist_table[i];
2326
        if (ist->decoding_needed) {
2327
            avcodec_close(ist->st->codec);
2328
        }
2329
    }
2330

    
2331
    /* finished ! */
2332
    ret = 0;
2333

    
2334
 fail:
2335
    av_freep(&bit_buffer);
2336
    av_free(file_table);
2337

    
2338
    if (ist_table) {
2339
        for(i=0;i<nb_istreams;i++) {
2340
            ist = ist_table[i];
2341
            av_free(ist);
2342
        }
2343
        av_free(ist_table);
2344
    }
2345
    if (ost_table) {
2346
        for(i=0;i<nb_ostreams;i++) {
2347
            ost = ost_table[i];
2348
            if (ost) {
2349
                if (ost->logfile) {
2350
                    fclose(ost->logfile);
2351
                    ost->logfile = NULL;
2352
                }
2353
                av_fifo_free(ost->fifo); /* works even if fifo is not
2354
                                             initialized but set to zero */
2355
                av_free(ost->pict_tmp.data[0]);
2356
                if (ost->video_resample)
2357
                    sws_freeContext(ost->img_resample_ctx);
2358
                if (ost->resample)
2359
                    audio_resample_close(ost->resample);
2360
                if (ost->reformat_ctx)
2361
                    av_audio_convert_free(ost->reformat_ctx);
2362
                av_free(ost);
2363
            }
2364
        }
2365
        av_free(ost_table);
2366
    }
2367
    return ret;
2368
}
2369

    
2370
#if 0
2371
int file_read(const char *filename)
2372
{
2373
    URLContext *h;
2374
    unsigned char buffer[1024];
2375
    int len, i;
2376

2377
    if (url_open(&h, filename, O_RDONLY) < 0) {
2378
        printf("could not open '%s'\n", filename);
2379
        return -1;
2380
    }
2381
    for(;;) {
2382
        len = url_read(h, buffer, sizeof(buffer));
2383
        if (len <= 0)
2384
            break;
2385
        for(i=0;i<len;i++) putchar(buffer[i]);
2386
    }
2387
    url_close(h);
2388
    return 0;
2389
}
2390
#endif
2391

    
2392
static void opt_format(const char *arg)
2393
{
2394
    /* compatibility stuff for pgmyuv */
2395
    if (!strcmp(arg, "pgmyuv")) {
2396
        pgmyuv_compatibility_hack=1;
2397
//        opt_image_format(arg);
2398
        arg = "image2";
2399
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2400
    }
2401

    
2402
    file_iformat = av_find_input_format(arg);
2403
    file_oformat = guess_format(arg, NULL, NULL);
2404
    if (!file_iformat && !file_oformat) {
2405
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2406
        av_exit(1);
2407
    }
2408
}
2409

    
2410
static void opt_video_rc_override_string(const char *arg)
2411
{
2412
    video_rc_override_string = arg;
2413
}
2414

    
2415
static int opt_me_threshold(const char *opt, const char *arg)
2416
{
2417
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2418
    return 0;
2419
}
2420

    
2421
static int opt_verbose(const char *opt, const char *arg)
2422
{
2423
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2424
    return 0;
2425
}
2426

    
2427
static int opt_frame_rate(const char *opt, const char *arg)
2428
{
2429
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2430
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2431
        av_exit(1);
2432
    }
2433
    return 0;
2434
}
2435

    
2436
static int opt_bitrate(const char *opt, const char *arg)
2437
{
2438
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2439

    
2440
    opt_default(opt, arg);
2441

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

    
2445
    return 0;
2446
}
2447

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

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

    
2476
static void opt_frame_crop_left(const char *arg)
2477
{
2478
    frame_leftBand = atoi(arg);
2479
    if (frame_leftBand < 0) {
2480
        fprintf(stderr, "Incorrect left crop size\n");
2481
        av_exit(1);
2482
    }
2483
    if ((frame_leftBand) >= frame_width){
2484
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2485
        av_exit(1);
2486
    }
2487
    frame_width -= frame_leftBand;
2488
}
2489

    
2490
static void opt_frame_crop_right(const char *arg)
2491
{
2492
    frame_rightBand = atoi(arg);
2493
    if (frame_rightBand < 0) {
2494
        fprintf(stderr, "Incorrect right crop size\n");
2495
        av_exit(1);
2496
    }
2497
    if ((frame_rightBand) >= frame_width){
2498
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2499
        av_exit(1);
2500
    }
2501
    frame_width -= frame_rightBand;
2502
}
2503

    
2504
static void opt_frame_size(const char *arg)
2505
{
2506
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2507
        fprintf(stderr, "Incorrect frame size\n");
2508
        av_exit(1);
2509
    }
2510
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2511
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2512
        av_exit(1);
2513
    }
2514
}
2515

    
2516
static void opt_pad_color(const char *arg) {
2517
    /* Input is expected to be six hex digits similar to
2518
       how colors are expressed in html tags (but without the #) */
2519
    int rgb = strtol(arg, NULL, 16);
2520
    int r,g,b;
2521

    
2522
    r = (rgb >> 16);
2523
    g = ((rgb >> 8) & 255);
2524
    b = (rgb & 255);
2525

    
2526
    padcolor[0] = RGB_TO_Y(r,g,b);
2527
    padcolor[1] = RGB_TO_U(r,g,b,0);
2528
    padcolor[2] = RGB_TO_V(r,g,b,0);
2529
}
2530

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

    
2540
static void opt_frame_pad_bottom(const char *arg)
2541
{
2542
    frame_padbottom = atoi(arg);
2543
    if (frame_padbottom < 0) {
2544
        fprintf(stderr, "Incorrect bottom pad size\n");
2545
        av_exit(1);
2546
    }
2547
}
2548

    
2549

    
2550
static void opt_frame_pad_left(const char *arg)
2551
{
2552
    frame_padleft = atoi(arg);
2553
    if (frame_padleft < 0) {
2554
        fprintf(stderr, "Incorrect left pad size\n");
2555
        av_exit(1);
2556
    }
2557
}
2558

    
2559

    
2560
static void opt_frame_pad_right(const char *arg)
2561
{
2562
    frame_padright = atoi(arg);
2563
    if (frame_padright < 0) {
2564
        fprintf(stderr, "Incorrect right pad size\n");
2565
        av_exit(1);
2566
    }
2567
}
2568

    
2569
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2570
{
2571
    int i;
2572
    char fmt_str[128];
2573
    for (i=-1; i < nb_fmts; i++) {
2574
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2575
        fprintf(stdout, "%s\n", fmt_str);
2576
    }
2577
}
2578

    
2579
static void opt_frame_pix_fmt(const char *arg)
2580
{
2581
    if (strcmp(arg, "list")) {
2582
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2583
        if (frame_pix_fmt == PIX_FMT_NONE) {
2584
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2585
            av_exit(1);
2586
        }
2587
    } else {
2588
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2589
        av_exit(0);
2590
    }
2591
}
2592

    
2593
static void opt_frame_aspect_ratio(const char *arg)
2594
{
2595
    int x = 0, y = 0;
2596
    double ar = 0;
2597
    const char *p;
2598
    char *end;
2599

    
2600
    p = strchr(arg, ':');
2601
    if (p) {
2602
        x = strtol(arg, &end, 10);
2603
        if (end == p)
2604
            y = strtol(end+1, &end, 10);
2605
        if (x > 0 && y > 0)
2606
            ar = (double)x / (double)y;
2607
    } else
2608
        ar = strtod(arg, NULL);
2609

    
2610
    if (!ar) {
2611
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2612
        av_exit(1);
2613
    }
2614
    frame_aspect_ratio = ar;
2615
}
2616

    
2617
static int opt_metadata(const char *opt, const char *arg)
2618
{
2619
    char *mid= strchr(arg, '=');
2620

    
2621
    if(!mid){
2622
        fprintf(stderr, "Missing =\n");
2623
        av_exit(1);
2624
    }
2625
    *mid++= 0;
2626

    
2627
    metadata_count++;
2628
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2629
    metadata[metadata_count-1].key  = av_strdup(arg);
2630
    metadata[metadata_count-1].value= av_strdup(mid);
2631

    
2632
    return 0;
2633
}
2634

    
2635
static void opt_qscale(const char *arg)
2636
{
2637
    video_qscale = atof(arg);
2638
    if (video_qscale <= 0 ||
2639
        video_qscale > 255) {
2640
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2641
        av_exit(1);
2642
    }
2643
}
2644

    
2645
static void opt_top_field_first(const char *arg)
2646
{
2647
    top_field_first= atoi(arg);
2648
}
2649

    
2650
static int opt_thread_count(const char *opt, const char *arg)
2651
{
2652
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2653
#if !HAVE_THREADS
2654
    if (verbose >= 0)
2655
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2656
#endif
2657
    return 0;
2658
}
2659

    
2660
static void opt_audio_sample_fmt(const char *arg)
2661
{
2662
    if (strcmp(arg, "list"))
2663
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2664
    else {
2665
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2666
        av_exit(0);
2667
    }
2668
}
2669

    
2670
static int opt_audio_rate(const char *opt, const char *arg)
2671
{
2672
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2673
    return 0;
2674
}
2675

    
2676
static int opt_audio_channels(const char *opt, const char *arg)
2677
{
2678
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2679
    return 0;
2680
}
2681

    
2682
static void opt_video_channel(const char *arg)
2683
{
2684
    video_channel = strtol(arg, NULL, 0);
2685
}
2686

    
2687
static void opt_video_standard(const char *arg)
2688
{
2689
    video_standard = av_strdup(arg);
2690
}
2691

    
2692
static void opt_codec(int *pstream_copy, char **pcodec_name,
2693
                      int codec_type, const char *arg)
2694
{
2695
    av_freep(pcodec_name);
2696
    if (!strcmp(arg, "copy")) {
2697
        *pstream_copy = 1;
2698
    } else {
2699
        *pcodec_name = av_strdup(arg);
2700
    }
2701
}
2702

    
2703
static void opt_audio_codec(const char *arg)
2704
{
2705
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2706
}
2707

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

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

    
2717
static void opt_video_tag(const char *arg)
2718
{
2719
    char *tail;
2720
    video_codec_tag= strtol(arg, &tail, 0);
2721

    
2722
    if(!tail || *tail)
2723
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2724
}
2725

    
2726
static void opt_video_codec(const char *arg)
2727
{
2728
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2729
}
2730

    
2731
static void opt_subtitle_codec(const char *arg)
2732
{
2733
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2734
}
2735

    
2736
static void opt_subtitle_tag(const char *arg)
2737
{
2738
    char *tail;
2739
    subtitle_codec_tag= strtol(arg, &tail, 0);
2740

    
2741
    if(!tail || *tail)
2742
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2743
}
2744

    
2745
static void opt_map(const char *arg)
2746
{
2747
    AVStreamMap *m;
2748
    char *p;
2749

    
2750
    m = &stream_maps[nb_stream_maps++];
2751

    
2752
    m->file_index = strtol(arg, &p, 0);
2753
    if (*p)
2754
        p++;
2755

    
2756
    m->stream_index = strtol(p, &p, 0);
2757
    if (*p) {
2758
        p++;
2759
        m->sync_file_index = strtol(p, &p, 0);
2760
        if (*p)
2761
            p++;
2762
        m->sync_stream_index = strtol(p, &p, 0);
2763
    } else {
2764
        m->sync_file_index = m->file_index;
2765
        m->sync_stream_index = m->stream_index;
2766
    }
2767
}
2768

    
2769
static void opt_map_meta_data(const char *arg)
2770
{
2771
    AVMetaDataMap *m;
2772
    char *p;
2773

    
2774
    m = &meta_data_maps[nb_meta_data_maps++];
2775

    
2776
    m->out_file = strtol(arg, &p, 0);
2777
    if (*p)
2778
        p++;
2779

    
2780
    m->in_file = strtol(p, &p, 0);
2781
}
2782

    
2783
static void opt_input_ts_scale(const char *arg)
2784
{
2785
    unsigned int stream;
2786
    double scale;
2787
    char *p;
2788

    
2789
    stream = strtol(arg, &p, 0);
2790
    if (*p)
2791
        p++;
2792
    scale= strtod(p, &p);
2793

    
2794
    if(stream >= MAX_STREAMS)
2795
        av_exit(1);
2796

    
2797
    input_files_ts_scale[nb_input_files][stream]= scale;
2798
}
2799

    
2800
static int opt_recording_time(const char *opt, const char *arg)
2801
{
2802
    recording_time = parse_time_or_die(opt, arg, 1);
2803
    return 0;
2804
}
2805

    
2806
static int opt_start_time(const char *opt, const char *arg)
2807
{
2808
    start_time = parse_time_or_die(opt, arg, 1);
2809
    return 0;
2810
}
2811

    
2812
static int opt_rec_timestamp(const char *opt, const char *arg)
2813
{
2814
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2815
    return 0;
2816
}
2817

    
2818
static int opt_input_ts_offset(const char *opt, const char *arg)
2819
{
2820
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2821
    return 0;
2822
}
2823

    
2824
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2825
{
2826
    const char *codec_string = encoder ? "encoder" : "decoder";
2827
    AVCodec *codec;
2828

    
2829
    if(!name)
2830
        return CODEC_ID_NONE;
2831
    codec = encoder ?
2832
        avcodec_find_encoder_by_name(name) :
2833
        avcodec_find_decoder_by_name(name);
2834
    if(!codec) {
2835
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2836
        av_exit(1);
2837
    }
2838
    if(codec->type != type) {
2839
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2840
        av_exit(1);
2841
    }
2842
    return codec->id;
2843
}
2844

    
2845
static void opt_input_file(const char *filename)
2846
{
2847
    AVFormatContext *ic;
2848
    AVFormatParameters params, *ap = &params;
2849
    int err, i, ret, rfps, rfps_base;
2850
    int64_t timestamp;
2851

    
2852
    if (!strcmp(filename, "-"))
2853
        filename = "pipe:";
2854

    
2855
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2856
                    !strcmp(filename, "/dev/stdin");
2857

    
2858
    /* get default parameters from command line */
2859
    ic = avformat_alloc_context();
2860

    
2861
    memset(ap, 0, sizeof(*ap));
2862
    ap->prealloced_context = 1;
2863
    ap->sample_rate = audio_sample_rate;
2864
    ap->channels = audio_channels;
2865
    ap->time_base.den = frame_rate.num;
2866
    ap->time_base.num = frame_rate.den;
2867
    ap->width = frame_width + frame_padleft + frame_padright;
2868
    ap->height = frame_height + frame_padtop + frame_padbottom;
2869
    ap->pix_fmt = frame_pix_fmt;
2870
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2871
    ap->channel = video_channel;
2872
    ap->standard = video_standard;
2873
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2874
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2875
    if(pgmyuv_compatibility_hack)
2876
        ap->video_codec_id= CODEC_ID_PGMYUV;
2877

    
2878
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2879

    
2880
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2881
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2882
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2883
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2884

    
2885
    /* open the input file with generic libav function */
2886
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2887
    if (err < 0) {
2888
        print_error(filename, err);
2889
        av_exit(1);
2890
    }
2891
    if(opt_programid) {
2892
        int i;
2893
        for(i=0; i<ic->nb_programs; i++)
2894
            if(ic->programs[i]->id != opt_programid)
2895
                ic->programs[i]->discard = AVDISCARD_ALL;
2896
    }
2897

    
2898
    ic->loop_input = loop_input;
2899

    
2900
    /* If not enough info to get the stream parameters, we decode the
2901
       first frames to get it. (used in mpeg case for example) */
2902
    ret = av_find_stream_info(ic);
2903
    if (ret < 0 && verbose >= 0) {
2904
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2905
        av_exit(1);
2906
    }
2907

    
2908
    timestamp = start_time;
2909
    /* add the stream start time */
2910
    if (ic->start_time != AV_NOPTS_VALUE)
2911
        timestamp += ic->start_time;
2912

    
2913
    /* if seeking requested, we execute it */
2914
    if (start_time != 0) {
2915
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2916
        if (ret < 0) {
2917
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2918
                    filename, (double)timestamp / AV_TIME_BASE);
2919
        }
2920
        /* reset seek info */
2921
        start_time = 0;
2922
    }
2923

    
2924
    /* update the current parameters so that they match the one of the input stream */
2925
    for(i=0;i<ic->nb_streams;i++) {
2926
        AVCodecContext *enc = ic->streams[i]->codec;
2927
        if(thread_count>1)
2928
            avcodec_thread_init(enc, thread_count);
2929
        enc->thread_count= thread_count;
2930
        switch(enc->codec_type) {
2931
        case CODEC_TYPE_AUDIO:
2932
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2933
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2934
            channel_layout = enc->channel_layout;
2935
            audio_channels = enc->channels;
2936
            audio_sample_rate = enc->sample_rate;
2937
            audio_sample_fmt = enc->sample_fmt;
2938
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2939
            if(audio_disable)
2940
                ic->streams[i]->discard= AVDISCARD_ALL;
2941
            break;
2942
        case CODEC_TYPE_VIDEO:
2943
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2944
            frame_height = enc->height;
2945
            frame_width = enc->width;
2946
            if(ic->streams[i]->sample_aspect_ratio.num)
2947
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2948
            else
2949
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2950
            frame_aspect_ratio *= (float) enc->width / enc->height;
2951
            frame_pix_fmt = enc->pix_fmt;
2952
            rfps      = ic->streams[i]->r_frame_rate.num;
2953
            rfps_base = ic->streams[i]->r_frame_rate.den;
2954
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2955
            if(me_threshold)
2956
                enc->debug |= FF_DEBUG_MV;
2957

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

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

    
2964
                    (float)rfps / rfps_base, rfps, rfps_base);
2965
            }
2966
            /* update the current frame rate to match the stream frame rate */
2967
            frame_rate.num = rfps;
2968
            frame_rate.den = rfps_base;
2969

    
2970
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2971
            if(video_disable)
2972
                ic->streams[i]->discard= AVDISCARD_ALL;
2973
            else if(video_discard)
2974
                ic->streams[i]->discard= video_discard;
2975
            break;
2976
        case CODEC_TYPE_DATA:
2977
            break;
2978
        case CODEC_TYPE_SUBTITLE:
2979
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2980
            if(subtitle_disable)
2981
                ic->streams[i]->discard = AVDISCARD_ALL;
2982
            break;
2983
        case CODEC_TYPE_ATTACHMENT:
2984
        case CODEC_TYPE_UNKNOWN:
2985
            nb_icodecs++;
2986
            break;
2987
        default:
2988
            abort();
2989
        }
2990
    }
2991

    
2992
    input_files[nb_input_files] = ic;
2993
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2994
    /* dump the file content */
2995
    if (verbose >= 0)
2996
        dump_format(ic, nb_input_files, filename, 0);
2997

    
2998
    nb_input_files++;
2999
    file_iformat = NULL;
3000
    file_oformat = NULL;
3001

    
3002
    video_channel = 0;
3003

    
3004
    av_freep(&video_codec_name);
3005
    av_freep(&audio_codec_name);
3006
    av_freep(&subtitle_codec_name);
3007
}
3008

    
3009
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3010
                                         int *has_subtitle_ptr)
3011
{
3012
    int has_video, has_audio, has_subtitle, i, j;
3013
    AVFormatContext *ic;
3014

    
3015
    has_video = 0;
3016
    has_audio = 0;
3017
    has_subtitle = 0;
3018
    for(j=0;j<nb_input_files;j++) {
3019
        ic = input_files[j];
3020
        for(i=0;i<ic->nb_streams;i++) {
3021
            AVCodecContext *enc = ic->streams[i]->codec;
3022
            switch(enc->codec_type) {
3023
            case CODEC_TYPE_AUDIO:
3024
                has_audio = 1;
3025
                break;
3026
            case CODEC_TYPE_VIDEO:
3027
                has_video = 1;
3028
                break;
3029
            case CODEC_TYPE_SUBTITLE:
3030
                has_subtitle = 1;
3031
                break;
3032
            case CODEC_TYPE_DATA:
3033
            case CODEC_TYPE_ATTACHMENT:
3034
            case CODEC_TYPE_UNKNOWN:
3035
                break;
3036
            default:
3037
                abort();
3038
            }
3039
        }
3040
    }
3041
    *has_video_ptr = has_video;
3042
    *has_audio_ptr = has_audio;
3043
    *has_subtitle_ptr = has_subtitle;
3044
}
3045

    
3046
static void new_video_stream(AVFormatContext *oc)
3047
{
3048
    AVStream *st;
3049
    AVCodecContext *video_enc;
3050
    int codec_id;
3051

    
3052
    st = av_new_stream(oc, oc->nb_streams);
3053
    if (!st) {
3054
        fprintf(stderr, "Could not alloc stream\n");
3055
        av_exit(1);
3056
    }
3057
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3058
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3059
    video_bitstream_filters= NULL;
3060

    
3061
    if(thread_count>1)
3062
        avcodec_thread_init(st->codec, thread_count);
3063

    
3064
    video_enc = st->codec;
3065

    
3066
    if(video_codec_tag)
3067
        video_enc->codec_tag= video_codec_tag;
3068

    
3069
    if(   (video_global_header&1)
3070
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3071
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3072
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3073
    }
3074
    if(video_global_header&2){
3075
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3076
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3077
    }
3078

    
3079
    if (video_stream_copy) {
3080
        st->stream_copy = 1;
3081
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3082
        video_enc->sample_aspect_ratio =
3083
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3084
    } else {
3085
        const char *p;
3086
        int i;
3087
        AVCodec *codec;
3088
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3089

    
3090
        if (video_codec_name) {
3091
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3092
            codec = avcodec_find_encoder_by_name(video_codec_name);
3093
            output_codecs[nb_ocodecs] = codec;
3094
        } else {
3095
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3096
            codec = avcodec_find_encoder(codec_id);
3097
        }
3098

    
3099
        video_enc->codec_id = codec_id;
3100

    
3101
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3102

    
3103
        if (codec && codec->supported_framerates && !force_fps)
3104
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3105
        video_enc->time_base.den = fps.num;
3106
        video_enc->time_base.num = fps.den;
3107

    
3108
        video_enc->width = frame_width + frame_padright + frame_padleft;
3109
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3110
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3111
        video_enc->pix_fmt = frame_pix_fmt;
3112
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3113

    
3114
        if(codec && codec->pix_fmts){
3115
            const enum PixelFormat *p= codec->pix_fmts;
3116
            for(; *p!=-1; p++){
3117
                if(*p == video_enc->pix_fmt)
3118
                    break;
3119
            }
3120
            if(*p == -1)
3121
                video_enc->pix_fmt = codec->pix_fmts[0];
3122
        }
3123

    
3124
        if (intra_only)
3125
            video_enc->gop_size = 0;
3126
        if (video_qscale || same_quality) {
3127
            video_enc->flags |= CODEC_FLAG_QSCALE;
3128
            video_enc->global_quality=
3129
                st->quality = FF_QP2LAMBDA * video_qscale;
3130
        }
3131

    
3132
        if(intra_matrix)
3133
            video_enc->intra_matrix = intra_matrix;
3134
        if(inter_matrix)
3135
            video_enc->inter_matrix = inter_matrix;
3136

    
3137
        video_enc->thread_count = thread_count;
3138
        p= video_rc_override_string;
3139
        for(i=0; p; i++){
3140
            int start, end, q;
3141
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3142
            if(e!=3){
3143
                fprintf(stderr, "error parsing rc_override\n");
3144
                av_exit(1);
3145
            }
3146
            video_enc->rc_override=
3147
                av_realloc(video_enc->rc_override,
3148
                           sizeof(RcOverride)*(i+1));
3149
            video_enc->rc_override[i].start_frame= start;
3150
            video_enc->rc_override[i].end_frame  = end;
3151
            if(q>0){
3152
                video_enc->rc_override[i].qscale= q;
3153
                video_enc->rc_override[i].quality_factor= 1.0;
3154
            }
3155
            else{
3156
                video_enc->rc_override[i].qscale= 0;
3157
                video_enc->rc_override[i].quality_factor= -q/100.0;
3158
            }
3159
            p= strchr(p, '/');
3160
            if(p) p++;
3161
        }
3162
        video_enc->rc_override_count=i;
3163
        if (!video_enc->rc_initial_buffer_occupancy)
3164
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3165
        video_enc->me_threshold= me_threshold;
3166
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3167

    
3168
        if (do_psnr)
3169
            video_enc->flags|= CODEC_FLAG_PSNR;
3170

    
3171
        /* two pass mode */
3172
        if (do_pass) {
3173
            if (do_pass == 1) {
3174
                video_enc->flags |= CODEC_FLAG_PASS1;
3175
            } else {
3176
                video_enc->flags |= CODEC_FLAG_PASS2;
3177
            }
3178
        }
3179
    }
3180
    nb_ocodecs++;
3181

    
3182
    /* reset some key parameters */
3183
    video_disable = 0;
3184
    av_freep(&video_codec_name);
3185
    video_stream_copy = 0;
3186
}
3187

    
3188
static void new_audio_stream(AVFormatContext *oc)
3189
{
3190
    AVStream *st;
3191
    AVCodecContext *audio_enc;
3192
    int codec_id;
3193

    
3194
    st = av_new_stream(oc, oc->nb_streams);
3195
    if (!st) {
3196
        fprintf(stderr, "Could not alloc stream\n");
3197
        av_exit(1);
3198
    }
3199
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3200

    
3201
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3202
    audio_bitstream_filters= NULL;
3203

    
3204
    if(thread_count>1)
3205
        avcodec_thread_init(st->codec, thread_count);
3206

    
3207
    audio_enc = st->codec;
3208
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3209

    
3210
    if(audio_codec_tag)
3211
        audio_enc->codec_tag= audio_codec_tag;
3212

    
3213
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3214
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3215
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3216
    }
3217
    if (audio_stream_copy) {
3218
        st->stream_copy = 1;
3219
        audio_enc->channels = audio_channels;
3220
    } else {
3221
        AVCodec *codec;
3222

    
3223
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3224

    
3225
        if (audio_codec_name) {
3226
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3227
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3228
            output_codecs[nb_ocodecs] = codec;
3229
        } else {
3230
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3231
            codec = avcodec_find_encoder(codec_id);
3232
        }
3233
        audio_enc->codec_id = codec_id;
3234

    
3235
        if (audio_qscale > QSCALE_NONE) {
3236
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3237
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3238
        }
3239
        audio_enc->thread_count = thread_count;
3240
        audio_enc->channels = audio_channels;
3241
        audio_enc->sample_fmt = audio_sample_fmt;
3242
        audio_enc->channel_layout = channel_layout;
3243
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3244
            audio_enc->channel_layout = 0;
3245

    
3246
        if(codec && codec->sample_fmts){
3247
            const enum SampleFormat *p= codec->sample_fmts;
3248
            for(; *p!=-1; p++){
3249
                if(*p == audio_enc->sample_fmt)
3250
                    break;
3251
            }
3252
            if(*p == -1)
3253
                audio_enc->sample_fmt = codec->sample_fmts[0];
3254
        }
3255
    }
3256
    nb_ocodecs++;
3257
    audio_enc->sample_rate = audio_sample_rate;
3258
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3259
    if (audio_language) {
3260
        av_metadata_set(&st->metadata, "language", audio_language);
3261
        av_free(audio_language);
3262
        audio_language = NULL;
3263
    }
3264

    
3265
    /* reset some key parameters */
3266
    audio_disable = 0;
3267
    av_freep(&audio_codec_name);
3268
    audio_stream_copy = 0;
3269
}
3270

    
3271
static void new_subtitle_stream(AVFormatContext *oc)
3272
{
3273
    AVStream *st;
3274
    AVCodecContext *subtitle_enc;
3275

    
3276
    st = av_new_stream(oc, oc->nb_streams);
3277
    if (!st) {
3278
        fprintf(stderr, "Could not alloc stream\n");
3279
        av_exit(1);
3280
    }
3281
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3282

    
3283
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3284
    subtitle_bitstream_filters= NULL;
3285

    
3286
    subtitle_enc = st->codec;
3287
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3288

    
3289
    if(subtitle_codec_tag)
3290
        subtitle_enc->codec_tag= subtitle_codec_tag;
3291

    
3292
    if (subtitle_stream_copy) {
3293
        st->stream_copy = 1;
3294
    } else {
3295
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3296
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3297
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3298
    }
3299
    nb_ocodecs++;
3300

    
3301
    if (subtitle_language) {
3302
        av_metadata_set(&st->metadata, "language", subtitle_language);
3303
        av_free(subtitle_language);
3304
        subtitle_language = NULL;
3305
    }
3306

    
3307
    subtitle_disable = 0;
3308
    av_freep(&subtitle_codec_name);
3309
    subtitle_stream_copy = 0;
3310
}
3311

    
3312
static void opt_new_audio_stream(void)
3313
{
3314
    AVFormatContext *oc;
3315
    if (nb_output_files <= 0) {
3316
        fprintf(stderr, "At least one output file must be specified\n");
3317
        av_exit(1);
3318
    }
3319
    oc = output_files[nb_output_files - 1];
3320
    new_audio_stream(oc);
3321
}
3322

    
3323
static void opt_new_video_stream(void)
3324
{
3325
    AVFormatContext *oc;
3326
    if (nb_output_files <= 0) {
3327
        fprintf(stderr, "At least one output file must be specified\n");
3328
        av_exit(1);
3329
    }
3330
    oc = output_files[nb_output_files - 1];
3331
    new_video_stream(oc);
3332
}
3333

    
3334
static void opt_new_subtitle_stream(void)
3335
{
3336
    AVFormatContext *oc;
3337
    if (nb_output_files <= 0) {
3338
        fprintf(stderr, "At least one output file must be specified\n");
3339
        av_exit(1);
3340
    }
3341
    oc = output_files[nb_output_files - 1];
3342
    new_subtitle_stream(oc);
3343
}
3344

    
3345
static void opt_output_file(const char *filename)
3346
{
3347
    AVFormatContext *oc;
3348
    int use_video, use_audio, use_subtitle;
3349
    int input_has_video, input_has_audio, input_has_subtitle;
3350
    AVFormatParameters params, *ap = &params;
3351

    
3352
    if (!strcmp(filename, "-"))
3353
        filename = "pipe:";
3354

    
3355
    oc = avformat_alloc_context();
3356

    
3357
    if (!file_oformat) {
3358
        file_oformat = guess_format(NULL, filename, NULL);
3359
        if (!file_oformat) {
3360
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3361
                    filename);
3362
            av_exit(1);
3363
        }
3364
    }
3365

    
3366
    oc->oformat = file_oformat;
3367
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3368

    
3369
    if (!strcmp(file_oformat->name, "ffm") &&
3370
        av_strstart(filename, "http:", NULL)) {
3371
        /* special case for files sent to ffserver: we get the stream
3372
           parameters from ffserver */
3373
        int err = read_ffserver_streams(oc, filename);
3374
        if (err < 0) {
3375
            print_error(filename, err);
3376
            av_exit(1);
3377
        }
3378
    } else {
3379
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3380
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3381
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3382

    
3383
        /* disable if no corresponding type found and at least one
3384
           input file */
3385
        if (nb_input_files > 0) {
3386
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3387
                                         &input_has_subtitle);
3388
            if (!input_has_video)
3389
                use_video = 0;
3390
            if (!input_has_audio)
3391
                use_audio = 0;
3392
            if (!input_has_subtitle)
3393
                use_subtitle = 0;
3394
        }
3395

    
3396
        /* manual disable */
3397
        if (audio_disable) {
3398
            use_audio = 0;
3399
        }
3400
        if (video_disable) {
3401
            use_video = 0;
3402
        }
3403
        if (subtitle_disable) {
3404
            use_subtitle = 0;
3405
        }
3406

    
3407
        if (use_video) {
3408
            new_video_stream(oc);
3409
        }
3410

    
3411
        if (use_audio) {
3412
            new_audio_stream(oc);
3413
        }
3414

    
3415
        if (use_subtitle) {
3416
            new_subtitle_stream(oc);
3417
        }
3418

    
3419
        oc->timestamp = rec_timestamp;
3420

    
3421
        for(; metadata_count>0; metadata_count--){
3422
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3423
                                           metadata[metadata_count-1].value);
3424
        }
3425
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3426
    }
3427

    
3428
    output_files[nb_output_files++] = oc;
3429

    
3430
    /* check filename in case of an image number is expected */
3431
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3432
        if (!av_filename_number_test(oc->filename)) {
3433
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3434
            av_exit(1);
3435
        }
3436
    }
3437

    
3438
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3439
        /* test if it already exists to avoid loosing precious files */
3440
        if (!file_overwrite &&
3441
            (strchr(filename, ':') == NULL ||
3442
             filename[1] == ':' ||
3443
             av_strstart(filename, "file:", NULL))) {
3444
            if (url_exist(filename)) {
3445
                if (!using_stdin) {
3446
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3447
                    fflush(stderr);
3448
                    if (!read_yesno()) {
3449
                        fprintf(stderr, "Not overwriting - exiting\n");
3450
                        av_exit(1);
3451
                    }
3452
                }
3453
                else {
3454
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3455
                    av_exit(1);
3456
                }
3457
            }
3458
        }
3459

    
3460
        /* open the file */
3461
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3462
            fprintf(stderr, "Could not open '%s'\n", filename);
3463
            av_exit(1);
3464
        }
3465
    }
3466

    
3467
    memset(ap, 0, sizeof(*ap));
3468
    if (av_set_parameters(oc, ap) < 0) {
3469
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3470
                oc->filename);
3471
        av_exit(1);
3472
    }
3473

    
3474
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3475
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3476
    oc->loop_output = loop_output;
3477
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3478

    
3479
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3480

    
3481
    /* reset some options */
3482
    file_oformat = NULL;
3483
    file_iformat = NULL;
3484
}
3485

    
3486
/* same option as mencoder */
3487
static void opt_pass(const char *pass_str)
3488
{
3489
    int pass;
3490
    pass = atoi(pass_str);
3491
    if (pass != 1 && pass != 2) {
3492
        fprintf(stderr, "pass number can be only 1 or 2\n");
3493
        av_exit(1);
3494
    }
3495
    do_pass = pass;
3496
}
3497

    
3498
static int64_t getutime(void)
3499
{
3500
#if HAVE_GETRUSAGE
3501
    struct rusage rusage;
3502

    
3503
    getrusage(RUSAGE_SELF, &rusage);
3504
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3505
#elif HAVE_GETPROCESSTIMES
3506
    HANDLE proc;
3507
    FILETIME c, e, k, u;
3508
    proc = GetCurrentProcess();
3509
    GetProcessTimes(proc, &c, &e, &k, &u);
3510
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3511
#else
3512
    return av_gettime();
3513
#endif
3514
}
3515

    
3516
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3517
{
3518
    int i;
3519
    const char *p = str;
3520
    for(i = 0;; i++) {
3521
        dest[i] = atoi(p);
3522
        if(i == 63)
3523
            break;
3524
        p = strchr(p, ',');
3525
        if(!p) {
3526
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3527
            av_exit(1);
3528
        }
3529
        p++;
3530
    }
3531
}
3532

    
3533
static void opt_inter_matrix(const char *arg)
3534
{
3535
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3536
    parse_matrix_coeffs(inter_matrix, arg);
3537
}
3538

    
3539
static void opt_intra_matrix(const char *arg)
3540
{
3541
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3542
    parse_matrix_coeffs(intra_matrix, arg);
3543
}
3544

    
3545
/**
3546
 * Trivial log callback.
3547
 * Only suitable for show_help and similar since it lacks prefix handling.
3548
 */
3549
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3550
{
3551
    vfprintf(stdout, fmt, vl);
3552
}
3553

    
3554
static void show_help(void)
3555
{
3556
    av_log_set_callback(log_callback_help);
3557
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3558
           "Hyper fast Audio and Video encoder\n");
3559
    printf("\n");
3560
    show_help_options(options, "Main options:\n",
3561
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3562
    show_help_options(options, "\nAdvanced options:\n",
3563
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3564
                      OPT_EXPERT);
3565
    show_help_options(options, "\nVideo options:\n",
3566
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3567
                      OPT_VIDEO);
3568
    show_help_options(options, "\nAdvanced Video options:\n",
3569
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3570
                      OPT_VIDEO | OPT_EXPERT);
3571
    show_help_options(options, "\nAudio options:\n",
3572
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3573
                      OPT_AUDIO);
3574
    show_help_options(options, "\nAdvanced Audio options:\n",
3575
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3576
                      OPT_AUDIO | OPT_EXPERT);
3577
    show_help_options(options, "\nSubtitle options:\n",
3578
                      OPT_SUBTITLE | OPT_GRAB,
3579
                      OPT_SUBTITLE);
3580
    show_help_options(options, "\nAudio/Video grab options:\n",
3581
                      OPT_GRAB,
3582
                      OPT_GRAB);
3583
    printf("\n");
3584
    av_opt_show(avcodec_opts[0], NULL);
3585
    printf("\n");
3586
    av_opt_show(avformat_opts, NULL);
3587
    printf("\n");
3588
    av_opt_show(sws_opts, NULL);
3589
}
3590

    
3591
static void opt_target(const char *arg)
3592
{
3593
    int norm = -1;
3594
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3595

    
3596
    if(!strncmp(arg, "pal-", 4)) {
3597
        norm = 0;
3598
        arg += 4;
3599
    } else if(!strncmp(arg, "ntsc-", 5)) {
3600
        norm = 1;
3601
        arg += 5;
3602
    } else if(!strncmp(arg, "film-", 5)) {
3603
        norm = 2;
3604
        arg += 5;
3605
    } else {
3606
        int fr;
3607
        /* Calculate FR via float to avoid int overflow */
3608
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3609
        if(fr == 25000) {
3610
            norm = 0;
3611
        } else if((fr == 29970) || (fr == 23976)) {
3612
            norm = 1;
3613
        } else {
3614
            /* Try to determine PAL/NTSC by peeking in the input files */
3615
            if(nb_input_files) {
3616
                int i, j;
3617
                for(j = 0; j < nb_input_files; j++) {
3618
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3619
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3620
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3621
                            continue;
3622
                        fr = c->time_base.den * 1000 / c->time_base.num;
3623
                        if(fr == 25000) {
3624
                            norm = 0;
3625
                            break;
3626
                        } else if((fr == 29970) || (fr == 23976)) {
3627
                            norm = 1;
3628
                            break;
3629
                        }
3630
                    }
3631
                    if(norm >= 0)
3632
                        break;
3633
                }
3634
            }
3635
        }
3636
        if(verbose && norm >= 0)
3637
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3638
    }
3639

    
3640
    if(norm < 0) {
3641
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3642
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3643
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3644
        av_exit(1);
3645
    }
3646

    
3647
    if(!strcmp(arg, "vcd")) {
3648

    
3649
        opt_video_codec("mpeg1video");
3650
        opt_audio_codec("mp2");
3651
        opt_format("vcd");
3652

    
3653
        opt_frame_size(norm ? "352x240" : "352x288");
3654
        opt_frame_rate(NULL, frame_rates[norm]);
3655
        opt_default("gop", norm ? "18" : "15");
3656

    
3657
        opt_default("b", "1150000");
3658
        opt_default("maxrate", "1150000");
3659
        opt_default("minrate", "1150000");
3660
        opt_default("bufsize", "327680"); // 40*1024*8;
3661

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

    
3666
        opt_default("packetsize", "2324");
3667
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3668

    
3669
        /* We have to offset the PTS, so that it is consistent with the SCR.
3670
           SCR starts at 36000, but the first two packs contain only padding
3671
           and the first pack from the other stream, respectively, may also have
3672
           been written before.
3673
           So the real data starts at SCR 36000+3*1200. */
3674
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3675
    } else if(!strcmp(arg, "svcd")) {
3676

    
3677
        opt_video_codec("mpeg2video");
3678
        opt_audio_codec("mp2");
3679
        opt_format("svcd");
3680

    
3681
        opt_frame_size(norm ? "480x480" : "480x576");
3682
        opt_frame_rate(NULL, frame_rates[norm]);
3683
        opt_default("gop", norm ? "18" : "15");
3684

    
3685
        opt_default("b", "2040000");
3686
        opt_default("maxrate", "2516000");
3687
        opt_default("minrate", "0"); //1145000;
3688
        opt_default("bufsize", "1835008"); //224*1024*8;
3689
        opt_default("flags", "+scan_offset");
3690

    
3691

    
3692
        opt_default("ab", "224000");
3693
        audio_sample_rate = 44100;
3694

    
3695
        opt_default("packetsize", "2324");
3696

    
3697
    } else if(!strcmp(arg, "dvd")) {
3698

    
3699
        opt_video_codec("mpeg2video");
3700
        opt_audio_codec("ac3");
3701
        opt_format("dvd");
3702

    
3703
        opt_frame_size(norm ? "720x480" : "720x576");
3704
        opt_frame_rate(NULL, frame_rates[norm]);
3705
        opt_default("gop", norm ? "18" : "15");
3706

    
3707
        opt_default("b", "6000000");
3708
        opt_default("maxrate", "9000000");
3709
        opt_default("minrate", "0"); //1500000;
3710
        opt_default("bufsize", "1835008"); //224*1024*8;
3711

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

    
3715
        opt_default("ab", "448000");
3716
        audio_sample_rate = 48000;
3717

    
3718
    } else if(!strncmp(arg, "dv", 2)) {
3719

    
3720
        opt_format("dv");
3721

    
3722
        opt_frame_size(norm ? "720x480" : "720x576");
3723
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3724
                                             (norm ? "yuv411p" : "yuv420p"));
3725
        opt_frame_rate(NULL, frame_rates[norm]);
3726

    
3727
        audio_sample_rate = 48000;
3728
        audio_channels = 2;
3729

    
3730
    } else {
3731
        fprintf(stderr, "Unknown target: %s\n", arg);
3732
        av_exit(1);
3733
    }
3734
}
3735

    
3736
static void opt_vstats_file (const char *arg)
3737
{
3738
    av_free (vstats_filename);
3739
    vstats_filename=av_strdup (arg);
3740
}
3741

    
3742
static void opt_vstats (void)
3743
{
3744
    char filename[40];
3745
    time_t today2 = time(NULL);
3746
    struct tm *today = localtime(&today2);
3747

    
3748
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3749
             today->tm_sec);
3750
    opt_vstats_file(filename);
3751
}
3752

    
3753
static int opt_bsf(const char *opt, const char *arg)
3754
{
3755
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3756
    AVBitStreamFilterContext **bsfp;
3757

    
3758
    if(!bsfc){
3759
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3760
        av_exit(1);
3761
    }
3762

    
3763
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3764
          *opt == 'a' ? &audio_bitstream_filters :
3765
                        &subtitle_bitstream_filters;
3766
    while(*bsfp)
3767
        bsfp= &(*bsfp)->next;
3768

    
3769
    *bsfp= bsfc;
3770

    
3771
    return 0;
3772
}
3773

    
3774
static int opt_preset(const char *opt, const char *arg)
3775
{
3776
    FILE *f=NULL;
3777
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3778
    int i;
3779
    const char *base[2]= { getenv("HOME"),
3780
                           FFMPEG_DATADIR,
3781
                         };
3782

    
3783
    for(i=!base[0]; i<2 && !f; i++){
3784
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3785
        f= fopen(filename, "r");
3786
        if(!f){
3787
            char *codec_name= *opt == 'v' ? video_codec_name :
3788
                              *opt == 'a' ? audio_codec_name :
3789
                                            subtitle_codec_name;
3790
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3791
            f= fopen(filename, "r");
3792
        }
3793
    }
3794
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3795
              is_dos_path(arg))){
3796
        av_strlcpy(filename, arg, sizeof(filename));
3797
        f= fopen(filename, "r");
3798
    }
3799

    
3800
    if(!f){
3801
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3802
        av_exit(1);
3803
    }
3804

    
3805
    while(!feof(f)){
3806
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3807
        if(line[0] == '#' && !e)
3808
            continue;
3809
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3810
        if(e){
3811
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3812
            av_exit(1);
3813
        }
3814
        if(!strcmp(tmp, "acodec")){
3815
            opt_audio_codec(tmp2);
3816
        }else if(!strcmp(tmp, "vcodec")){
3817
            opt_video_codec(tmp2);
3818
        }else if(!strcmp(tmp, "scodec")){
3819
            opt_subtitle_codec(tmp2);
3820
        }else if(opt_default(tmp, tmp2) < 0){
3821
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3822
            av_exit(1);
3823
        }
3824
    }
3825

    
3826
    fclose(f);
3827

    
3828
    return 0;
3829
}
3830

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

    
3874
    /* video options */
3875
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3876
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3877
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3878
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3879
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3880
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3881
    { "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" },
3882
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3883
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3884
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3885
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3886
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3887
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3888
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3889
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3890
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3891
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3892
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3893
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3894
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3895
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3896
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3897
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3898
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3899
      "use same video quality as source (implies VBR)" },
3900
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3901
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3902
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3903
      "deinterlace pictures" },
3904
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3905
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3906
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3907
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3908
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3909
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3910
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3911
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3912
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3913
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3914
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3915

    
3916
    /* audio options */
3917
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3918
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3919
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3920
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3921
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3922
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3923
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3924
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3925
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3926
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3927
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3928
    { "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" },
3929

    
3930
    /* subtitle options */
3931
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3932
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3933
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3934
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3935
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3936

    
3937
    /* grab options */
3938
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3939
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3940
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3941

    
3942
    /* muxer options */
3943
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3944
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3945

    
3946
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3947
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3948
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3949

    
3950
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3951
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3952
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3953

    
3954
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3955
    { NULL, },
3956
};
3957

    
3958
int main(int argc, char **argv)
3959
{
3960
    int i;
3961
    int64_t ti;
3962

    
3963
    avcodec_register_all();
3964
    avdevice_register_all();
3965
    av_register_all();
3966

    
3967
    if(isatty(STDIN_FILENO))
3968
        url_set_interrupt_cb(decode_interrupt_cb);
3969

    
3970
    for(i=0; i<CODEC_TYPE_NB; i++){
3971
        avcodec_opts[i]= avcodec_alloc_context2(i);
3972
    }
3973
    avformat_opts = avformat_alloc_context();
3974
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3975

    
3976
    show_banner();
3977

    
3978
    /* parse options */
3979
    parse_options(argc, argv, options, opt_output_file);
3980

    
3981
    /* file converter / grab */
3982
    if (nb_output_files <= 0) {
3983
        fprintf(stderr, "At least one output file must be specified\n");
3984
        av_exit(1);
3985
    }
3986

    
3987
    if (nb_input_files == 0) {
3988
        fprintf(stderr, "At least one input file must be specified\n");
3989
        av_exit(1);
3990
    }
3991

    
3992
    ti = getutime();
3993
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3994
                  stream_maps, nb_stream_maps) < 0)
3995
        av_exit(1);
3996
    ti = getutime() - ti;
3997
    if (do_benchmark) {
3998
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3999
    }
4000

    
4001
    return av_exit(0);
4002
}