Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ ce1ee094

History | View | Annotate | Download (135 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
#include "config.h"
23
#include <ctype.h>
24
#include <string.h>
25
#include <math.h>
26
#include <stdlib.h>
27
#include <errno.h>
28
#include <signal.h>
29
#include <limits.h>
30
#include "libavformat/avformat.h"
31
#include "libavdevice/avdevice.h"
32
#include "libswscale/swscale.h"
33
#include "libavformat/framehook.h"
34
#include "libavcodec/opt.h"
35
#include "libavcodec/audioconvert.h"
36
#include "libavutil/fifo.h"
37
#include "libavutil/avstring.h"
38
#include "libavformat/os_support.h"
39

    
40
#ifdef HAVE_SYS_RESOURCE_H
41
#include <sys/types.h>
42
#include <sys/resource.h>
43
#elif defined(HAVE_GETPROCESSTIMES)
44
#include <windows.h>
45
#endif
46

    
47
#if defined(HAVE_TERMIOS_H)
48
#include <unistd.h>
49
#include <fcntl.h>
50
#include <sys/ioctl.h>
51
#include <sys/time.h>
52
#include <termios.h>
53
#elif defined(HAVE_CONIO_H)
54
#include <conio.h>
55
#endif
56
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
57
#include <time.h>
58

    
59
#include "cmdutils.h"
60

    
61
#undef NDEBUG
62
#include <assert.h>
63

    
64
#undef exit
65

    
66
const char program_name[] = "FFmpeg";
67
const int program_birth_year = 2000;
68

    
69
/* select an input stream for an output stream */
70
typedef struct AVStreamMap {
71
    int file_index;
72
    int stream_index;
73
    int sync_file_index;
74
    int sync_stream_index;
75
} AVStreamMap;
76

    
77
/** select an input file for an output file */
78
typedef struct AVMetaDataMap {
79
    int out_file;
80
    int in_file;
81
} AVMetaDataMap;
82

    
83
static const OptionDef options[];
84

    
85
#define MAX_FILES 20
86

    
87
static AVFormatContext *input_files[MAX_FILES];
88
static int64_t input_files_ts_offset[MAX_FILES];
89
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
90
static int nb_input_files = 0;
91

    
92
static AVFormatContext *output_files[MAX_FILES];
93
static int nb_output_files = 0;
94

    
95
static AVStreamMap stream_maps[MAX_FILES];
96
static int nb_stream_maps;
97

    
98
static AVMetaDataMap meta_data_maps[MAX_FILES];
99
static int nb_meta_data_maps;
100

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

    
141
static int intra_only = 0;
142
static int audio_sample_rate = 44100;
143
#define QSCALE_NONE -99999
144
static float audio_qscale = QSCALE_NONE;
145
static int audio_disable = 0;
146
static int audio_channels = 1;
147
static char  *audio_codec_name = NULL;
148
static int audio_codec_tag = 0;
149
static char *audio_language = NULL;
150

    
151
static int subtitle_disable = 0;
152
static char *subtitle_codec_name = NULL;
153
static char *subtitle_language = NULL;
154

    
155
static float mux_preload= 0.5;
156
static float mux_max_delay= 0.7;
157

    
158
static int64_t recording_time = INT64_MAX;
159
static int64_t start_time = 0;
160
static int64_t rec_timestamp = 0;
161
static int64_t input_ts_offset = 0;
162
static int file_overwrite = 0;
163
static char *str_title = NULL;
164
static char *str_author = NULL;
165
static char *str_copyright = NULL;
166
static char *str_comment = NULL;
167
static char *str_genre = NULL;
168
static char *str_album = NULL;
169
static int do_benchmark = 0;
170
static int do_hex_dump = 0;
171
static int do_pkt_dump = 0;
172
static int do_psnr = 0;
173
static int do_pass = 0;
174
static char *pass_logfilename = NULL;
175
static int audio_stream_copy = 0;
176
static int video_stream_copy = 0;
177
static int subtitle_stream_copy = 0;
178
static int video_sync_method= -1;
179
static int audio_sync_method= 0;
180
static float audio_drift_threshold= 0.1;
181
static int copy_ts= 0;
182
static int opt_shortest = 0; //
183
static int video_global_header = 0;
184
static char *vstats_filename;
185
static FILE *vstats_file;
186
static int opt_programid = 0;
187

    
188
static int rate_emu = 0;
189

    
190
static int  video_channel = 0;
191
static char *video_standard;
192

    
193
static int audio_volume = 256;
194

    
195
static int using_stdin = 0;
196
static int using_vhook = 0;
197
static int verbose = 1;
198
static int thread_count= 1;
199
static int q_pressed = 0;
200
static int64_t video_size = 0;
201
static int64_t audio_size = 0;
202
static int64_t extra_size = 0;
203
static int nb_frames_dup = 0;
204
static int nb_frames_drop = 0;
205
static int input_sync;
206
static uint64_t limit_filesize = 0; //
207

    
208
static int pgmyuv_compatibility_hack=0;
209
static float dts_delta_threshold = 10;
210

    
211
static unsigned int sws_flags = SWS_BICUBIC;
212

    
213
static const char **opt_names;
214
static int opt_name_count;
215
static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
216
static AVFormatContext *avformat_opts;
217
static struct SwsContext *sws_opts;
218
static int64_t timer_start;
219

    
220
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
221
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
222
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
223
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
224

    
225
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
226

    
227
struct AVInputStream;
228

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

    
247
    int video_crop;
248
    int topBand;             /* cropping area sizes */
249
    int leftBand;
250

    
251
    int video_pad;
252
    int padtop;              /* padding area sizes */
253
    int padbottom;
254
    int padleft;
255
    int padright;
256

    
257
    /* audio only */
258
    int audio_resample;
259
    ReSampleContext *resample; /* for audio resampling */
260
    AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
261
    FILE *logfile;
262
} AVOutputStream;
263

    
264
typedef struct AVInputStream {
265
    int file_index;
266
    int index;
267
    AVStream *st;
268
    int discard;             /* true if stream data should be discarded */
269
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
270
    int64_t sample_index;      /* current sample */
271

    
272
    int64_t       start;     /* time when read started */
273
    unsigned long frame;     /* current frame */
274
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
275
                                is not defined */
276
    int64_t       pts;       /* current pts */
277
    int is_start;            /* is 1 at the start and after a discontinuity */
278
} AVInputStream;
279

    
280
typedef struct AVInputFile {
281
    int eof_reached;      /* true if eof reached */
282
    int ist_index;        /* index of first stream in ist_table */
283
    int buffer_size;      /* current total buffer size */
284
    int nb_streams;       /* nb streams we are aware of */
285
} AVInputFile;
286

    
287
#ifdef HAVE_TERMIOS_H
288

    
289
/* init terminal so that we can grab keys */
290
static struct termios oldtty;
291
#endif
292

    
293
static void term_exit(void)
294
{
295
#ifdef HAVE_TERMIOS_H
296
    tcsetattr (0, TCSANOW, &oldtty);
297
#endif
298
}
299

    
300
static volatile sig_atomic_t received_sigterm = 0;
301

    
302
static void
303
sigterm_handler(int sig)
304
{
305
    received_sigterm = sig;
306
    term_exit();
307
}
308

    
309
static void term_init(void)
310
{
311
#ifdef HAVE_TERMIOS_H
312
    struct termios tty;
313

    
314
    tcgetattr (0, &tty);
315
    oldtty = tty;
316

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

    
326
    tcsetattr (0, TCSANOW, &tty);
327
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
328
#endif
329

    
330
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
331
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
332
    /*
333
    register a function to be called at normal program termination
334
    */
335
    atexit(term_exit);
336
#ifdef CONFIG_BEOS_NETSERVER
337
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
338
#endif
339
}
340

    
341
/* read a key without blocking */
342
static int read_key(void)
343
{
344
#if defined(HAVE_TERMIOS_H)
345
    int n = 1;
346
    unsigned char ch;
347
#ifndef CONFIG_BEOS_NETSERVER
348
    struct timeval tv;
349
    fd_set rfds;
350

    
351
    FD_ZERO(&rfds);
352
    FD_SET(0, &rfds);
353
    tv.tv_sec = 0;
354
    tv.tv_usec = 0;
355
    n = select(1, &rfds, NULL, NULL, &tv);
356
#endif
357
    if (n > 0) {
358
        n = read(0, &ch, 1);
359
        if (n == 1)
360
            return ch;
361

    
362
        return n;
363
    }
364
#elif defined(HAVE_CONIO_H)
365
    if(kbhit())
366
        return(getch());
367
#endif
368
    return -1;
369
}
370

    
371
static int decode_interrupt_cb(void)
372
{
373
    return q_pressed || (q_pressed = read_key() == 'q');
374
}
375

    
376
static int av_exit(int ret)
377
{
378
    int i;
379

    
380
    /* close files */
381
    for(i=0;i<nb_output_files;i++) {
382
        /* maybe av_close_output_file ??? */
383
        AVFormatContext *s = output_files[i];
384
        int j;
385
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
386
            url_fclose(s->pb);
387
        for(j=0;j<s->nb_streams;j++) {
388
            av_free(s->streams[j]->codec);
389
            av_free(s->streams[j]);
390
        }
391
        av_free(s);
392
    }
393
    for(i=0;i<nb_input_files;i++)
394
        av_close_input_file(input_files[i]);
395

    
396
    av_free(intra_matrix);
397
    av_free(inter_matrix);
398

    
399
    if (vstats_file)
400
        fclose(vstats_file);
401
    av_free(vstats_filename);
402

    
403
    av_free(opt_names);
404

    
405
    av_free(video_codec_name);
406
    av_free(audio_codec_name);
407
    av_free(subtitle_codec_name);
408

    
409
    av_free(video_standard);
410

    
411
#ifdef CONFIG_POWERPC_PERF
412
    extern void powerpc_display_perf_report(void);
413
    powerpc_display_perf_report();
414
#endif /* CONFIG_POWERPC_PERF */
415

    
416
    if (received_sigterm) {
417
        fprintf(stderr,
418
            "Received signal %d: terminating.\n",
419
            (int) received_sigterm);
420
        exit (255);
421
    }
422

    
423
    exit(ret); /* not all OS-es handle main() return value */
424
    return ret;
425
}
426

    
427
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
428
{
429
    int i, err;
430
    AVFormatContext *ic;
431
    int nopts = 0;
432

    
433
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
434
    if (err < 0)
435
        return err;
436
    /* copy stream format */
437
    s->nb_streams = ic->nb_streams;
438
    for(i=0;i<ic->nb_streams;i++) {
439
        AVStream *st;
440

    
441
        // FIXME: a more elegant solution is needed
442
        st = av_mallocz(sizeof(AVStream));
443
        memcpy(st, ic->streams[i], sizeof(AVStream));
444
        st->codec = avcodec_alloc_context();
445
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
446
        s->streams[i] = st;
447

    
448
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
449
            st->stream_copy = 1;
450
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
451
            st->stream_copy = 1;
452

    
453
        if(!st->codec->thread_count)
454
            st->codec->thread_count = 1;
455
        if(st->codec->thread_count>1)
456
            avcodec_thread_init(st->codec, st->codec->thread_count);
457

    
458
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
459
            nopts = 1;
460
    }
461

    
462
    if (!nopts)
463
        s->timestamp = av_gettime();
464

    
465
    av_close_input_file(ic);
466
    return 0;
467
}
468

    
469
static double
470
get_sync_ipts(const AVOutputStream *ost)
471
{
472
    const AVInputStream *ist = ost->sync_ist;
473
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
474
}
475

    
476
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
477
    int ret;
478

    
479
    while(bsfc){
480
        AVPacket new_pkt= *pkt;
481
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
482
                                          &new_pkt.data, &new_pkt.size,
483
                                          pkt->data, pkt->size,
484
                                          pkt->flags & PKT_FLAG_KEY);
485
        if(a>0){
486
            av_free_packet(pkt);
487
            new_pkt.destruct= av_destruct_packet;
488
        } else if(a<0){
489
            fprintf(stderr, "%s failed for stream %d, codec %s",
490
                    bsfc->filter->name, pkt->stream_index,
491
                    avctx->codec ? avctx->codec->name : "copy");
492
            print_error("", a);
493
        }
494
        *pkt= new_pkt;
495

    
496
        bsfc= bsfc->next;
497
    }
498

    
499
    ret= av_interleaved_write_frame(s, pkt);
500
    if(ret < 0){
501
        print_error("av_interleaved_write_frame()", ret);
502
        av_exit(1);
503
    }
504
}
505

    
506
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
507

    
508
static void do_audio_out(AVFormatContext *s,
509
                         AVOutputStream *ost,
510
                         AVInputStream *ist,
511
                         unsigned char *buf, int size)
512
{
513
    uint8_t *buftmp;
514
    static uint8_t *audio_buf = NULL;
515
    static uint8_t *audio_out = NULL;
516
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
517

    
518
    int size_out, frame_bytes, ret;
519
    AVCodecContext *enc= ost->st->codec;
520
    AVCodecContext *dec= ist->st->codec;
521

    
522
    /* SC: dynamic allocation of buffers */
523
    if (!audio_buf)
524
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
525
    if (!audio_out)
526
        audio_out = av_malloc(audio_out_size);
527
    if (!audio_buf || !audio_out)
528
        return;               /* Should signal an error ! */
529

    
530
    if (enc->channels != dec->channels)
531
        ost->audio_resample = 1;
532

    
533
    if (ost->audio_resample && !ost->resample) {
534
        ost->resample = audio_resample_init(enc->channels,    dec->channels,
535
                                            enc->sample_rate, dec->sample_rate);
536
        if (!ost->resample) {
537
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
538
                    dec->channels, dec->sample_rate,
539
                    enc->channels, enc->sample_rate);
540
            av_exit(1);
541
        }
542
    }
543

    
544
    if(audio_sync_method){
545
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
546
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
547
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
548
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
549

    
550
        //FIXME resample delay
551
        if(fabs(delta) > 50){
552
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
553
                if(byte_delta < 0){
554
                    byte_delta= FFMAX(byte_delta, -size);
555
                    size += byte_delta;
556
                    buf  -= byte_delta;
557
                    if(verbose > 2)
558
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
559
                    if(!size)
560
                        return;
561
                    ist->is_start=0;
562
                }else{
563
                    static uint8_t *input_tmp= NULL;
564
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
565

    
566
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
567
                        ist->is_start=0;
568
                    else
569
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
570

    
571
                    memset(input_tmp, 0, byte_delta);
572
                    memcpy(input_tmp + byte_delta, buf, size);
573
                    buf= input_tmp;
574
                    size += byte_delta;
575
                    if(verbose > 2)
576
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
577
                }
578
            }else if(audio_sync_method>1){
579
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
580
                assert(ost->audio_resample);
581
                if(verbose > 2)
582
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
583
//                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));
584
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
585
            }
586
        }
587
    }else
588
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
589
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
590

    
591
    if (ost->audio_resample) {
592
        buftmp = audio_buf;
593
        size_out = audio_resample(ost->resample,
594
                                  (short *)buftmp, (short *)buf,
595
                                  size / (ist->st->codec->channels * 2));
596
        size_out = size_out * enc->channels * 2;
597
    } else {
598
        buftmp = buf;
599
        size_out = size;
600
    }
601

    
602
    /* now encode as many frames as possible */
603
    if (enc->frame_size > 1) {
604
        /* output resampled raw samples */
605
        av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out);
606
        av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
607

    
608
        frame_bytes = enc->frame_size * 2 * enc->channels;
609

    
610
        while (av_fifo_size(&ost->fifo) >= frame_bytes) {
611
            AVPacket pkt;
612
            av_init_packet(&pkt);
613

    
614
            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
615

    
616
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
617

    
618
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
619
                                       (short *)audio_buf);
620
            audio_size += ret;
621
            pkt.stream_index= ost->index;
622
            pkt.data= audio_out;
623
            pkt.size= ret;
624
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
625
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
626
            pkt.flags |= PKT_FLAG_KEY;
627
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
628

    
629
            ost->sync_opts += enc->frame_size;
630
        }
631
    } else {
632
        AVPacket pkt;
633
        av_init_packet(&pkt);
634

    
635
        ost->sync_opts += size_out / (2 * enc->channels);
636

    
637
        /* output a pcm frame */
638
        /* XXX: change encoding codec API to avoid this ? */
639
        switch(enc->codec->id) {
640
        case CODEC_ID_PCM_S32LE:
641
        case CODEC_ID_PCM_S32BE:
642
        case CODEC_ID_PCM_U32LE:
643
        case CODEC_ID_PCM_U32BE:
644
        case CODEC_ID_PCM_F32BE:
645
            size_out = size_out << 1;
646
            break;
647
        case CODEC_ID_PCM_S24LE:
648
        case CODEC_ID_PCM_S24BE:
649
        case CODEC_ID_PCM_U24LE:
650
        case CODEC_ID_PCM_U24BE:
651
        case CODEC_ID_PCM_S24DAUD:
652
            size_out = size_out / 2 * 3;
653
            break;
654
        case CODEC_ID_PCM_S16LE:
655
        case CODEC_ID_PCM_S16BE:
656
        case CODEC_ID_PCM_U16LE:
657
        case CODEC_ID_PCM_U16BE:
658
            break;
659
        default:
660
            size_out = size_out >> 1;
661
            break;
662
        }
663
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
664
        ret = avcodec_encode_audio(enc, audio_out, size_out,
665
                                   (short *)buftmp);
666
        audio_size += ret;
667
        pkt.stream_index= ost->index;
668
        pkt.data= audio_out;
669
        pkt.size= ret;
670
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
671
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
672
        pkt.flags |= PKT_FLAG_KEY;
673
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
674
    }
675
}
676

    
677
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
678
{
679
    AVCodecContext *dec;
680
    AVPicture *picture2;
681
    AVPicture picture_tmp;
682
    uint8_t *buf = 0;
683

    
684
    dec = ist->st->codec;
685

    
686
    /* deinterlace : must be done before any resize */
687
    if (do_deinterlace || using_vhook) {
688
        int size;
689

    
690
        /* create temporary picture */
691
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
692
        buf = av_malloc(size);
693
        if (!buf)
694
            return;
695

    
696
        picture2 = &picture_tmp;
697
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
698

    
699
        if (do_deinterlace){
700
            if(avpicture_deinterlace(picture2, picture,
701
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
702
                /* if error, do not deinterlace */
703
                av_free(buf);
704
                buf = NULL;
705
                picture2 = picture;
706
            }
707
        } else {
708
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
709
        }
710
    } else {
711
        picture2 = picture;
712
    }
713

    
714
    if (ENABLE_VHOOK)
715
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
716
                           1000000 * ist->pts / AV_TIME_BASE);
717

    
718
    if (picture != picture2)
719
        *picture = *picture2;
720
    *bufp = buf;
721
}
722

    
723
/* we begin to correct av delay at this threshold */
724
#define AV_DELAY_MAX 0.100
725

    
726
static void do_subtitle_out(AVFormatContext *s,
727
                            AVOutputStream *ost,
728
                            AVInputStream *ist,
729
                            AVSubtitle *sub,
730
                            int64_t pts)
731
{
732
    static uint8_t *subtitle_out = NULL;
733
    int subtitle_out_max_size = 65536;
734
    int subtitle_out_size, nb, i;
735
    AVCodecContext *enc;
736
    AVPacket pkt;
737

    
738
    if (pts == AV_NOPTS_VALUE) {
739
        fprintf(stderr, "Subtitle packets must have a pts\n");
740
        return;
741
    }
742

    
743
    enc = ost->st->codec;
744

    
745
    if (!subtitle_out) {
746
        subtitle_out = av_malloc(subtitle_out_max_size);
747
    }
748

    
749
    /* Note: DVB subtitle need one packet to draw them and one other
750
       packet to clear them */
751
    /* XXX: signal it in the codec context ? */
752
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
753
        nb = 2;
754
    else
755
        nb = 1;
756

    
757
    for(i = 0; i < nb; i++) {
758
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
759
                                                    subtitle_out_max_size, sub);
760

    
761
        av_init_packet(&pkt);
762
        pkt.stream_index = ost->index;
763
        pkt.data = subtitle_out;
764
        pkt.size = subtitle_out_size;
765
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
766
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
767
            /* XXX: the pts correction is handled here. Maybe handling
768
               it in the codec would be better */
769
            if (i == 0)
770
                pkt.pts += 90 * sub->start_display_time;
771
            else
772
                pkt.pts += 90 * sub->end_display_time;
773
        }
774
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
775
    }
776
}
777

    
778
static int bit_buffer_size= 1024*256;
779
static uint8_t *bit_buffer= NULL;
780

    
781
static void do_video_out(AVFormatContext *s,
782
                         AVOutputStream *ost,
783
                         AVInputStream *ist,
784
                         AVFrame *in_picture,
785
                         int *frame_size)
786
{
787
    int nb_frames, i, ret;
788
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
789
    AVFrame picture_crop_temp, picture_pad_temp;
790
    AVCodecContext *enc, *dec;
791

    
792
    avcodec_get_frame_defaults(&picture_crop_temp);
793
    avcodec_get_frame_defaults(&picture_pad_temp);
794

    
795
    enc = ost->st->codec;
796
    dec = ist->st->codec;
797

    
798
    /* by default, we output a single frame */
799
    nb_frames = 1;
800

    
801
    *frame_size = 0;
802

    
803
    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
804
        double vdelta;
805
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
806
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
807
        if (vdelta < -1.1)
808
            nb_frames = 0;
809
        else if (video_sync_method == 2)
810
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
811
        else if (vdelta > 1.1)
812
            nb_frames = lrintf(vdelta);
813
//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
814
        if (nb_frames == 0){
815
            ++nb_frames_drop;
816
            if (verbose>2)
817
                fprintf(stderr, "*** drop!\n");
818
        }else if (nb_frames > 1) {
819
            nb_frames_dup += nb_frames;
820
            if (verbose>2)
821
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
822
        }
823
    }else
824
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
825

    
826
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
827
    if (nb_frames <= 0)
828
        return;
829

    
830
    if (ost->video_crop) {
831
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
832
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
833
            return;
834
        }
835
        formatted_picture = &picture_crop_temp;
836
    } else {
837
        formatted_picture = in_picture;
838
    }
839

    
840
    final_picture = formatted_picture;
841
    padding_src = formatted_picture;
842
    resampling_dst = &ost->pict_tmp;
843
    if (ost->video_pad) {
844
        final_picture = &ost->pict_tmp;
845
        if (ost->video_resample) {
846
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
847
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
848
                return;
849
            }
850
            resampling_dst = &picture_pad_temp;
851
        }
852
    }
853

    
854
    if (ost->video_resample) {
855
        padding_src = NULL;
856
        final_picture = &ost->pict_tmp;
857
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
858
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
859
    }
860

    
861
    if (ost->video_pad) {
862
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
863
                enc->height, enc->width, enc->pix_fmt,
864
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
865
    }
866

    
867
    /* duplicates frame if needed */
868
    for(i=0;i<nb_frames;i++) {
869
        AVPacket pkt;
870
        av_init_packet(&pkt);
871
        pkt.stream_index= ost->index;
872

    
873
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
874
            /* raw pictures are written as AVPicture structure to
875
               avoid any copies. We support temorarily the older
876
               method. */
877
            AVFrame* old_frame = enc->coded_frame;
878
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
879
            pkt.data= (uint8_t *)final_picture;
880
            pkt.size=  sizeof(AVPicture);
881
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
882
            pkt.flags |= PKT_FLAG_KEY;
883

    
884
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
885
            enc->coded_frame = old_frame;
886
        } else {
887
            AVFrame big_picture;
888

    
889
            big_picture= *final_picture;
890
            /* better than nothing: use input picture interlaced
891
               settings */
892
            big_picture.interlaced_frame = in_picture->interlaced_frame;
893
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
894
                if(top_field_first == -1)
895
                    big_picture.top_field_first = in_picture->top_field_first;
896
                else
897
                    big_picture.top_field_first = top_field_first;
898
            }
899

    
900
            /* handles sameq here. This is not correct because it may
901
               not be a global option */
902
            if (same_quality) {
903
                big_picture.quality = ist->st->quality;
904
            }else
905
                big_picture.quality = ost->st->quality;
906
            if(!me_threshold)
907
                big_picture.pict_type = 0;
908
//            big_picture.pts = AV_NOPTS_VALUE;
909
            big_picture.pts= ost->sync_opts;
910
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
911
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
912
            ret = avcodec_encode_video(enc,
913
                                       bit_buffer, bit_buffer_size,
914
                                       &big_picture);
915
            if (ret == -1) {
916
                fprintf(stderr, "Video encoding failed\n");
917
                av_exit(1);
918
            }
919
            //enc->frame_number = enc->real_pict_num;
920
            if(ret>0){
921
                pkt.data= bit_buffer;
922
                pkt.size= ret;
923
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
924
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
925
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
926
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
927
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
928

    
929
                if(enc->coded_frame->key_frame)
930
                    pkt.flags |= PKT_FLAG_KEY;
931
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
932
                *frame_size = ret;
933
                video_size += ret;
934
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
935
                //        enc->frame_number-1, enc->real_pict_num, ret,
936
                //        enc->pict_type);
937
                /* if two pass, output log */
938
                if (ost->logfile && enc->stats_out) {
939
                    fprintf(ost->logfile, "%s", enc->stats_out);
940
                }
941
            }
942
        }
943
        ost->sync_opts++;
944
        ost->frame_number++;
945
    }
946
}
947

    
948
static double psnr(double d){
949
    return -10.0*log(d)/log(10.0);
950
}
951

    
952
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
953
                           int frame_size)
954
{
955
    AVCodecContext *enc;
956
    int frame_number;
957
    double ti1, bitrate, avg_bitrate;
958

    
959
    /* this is executed just the first time do_video_stats is called */
960
    if (!vstats_file) {
961
        vstats_file = fopen(vstats_filename, "w");
962
        if (!vstats_file) {
963
            perror("fopen");
964
            av_exit(1);
965
        }
966
    }
967

    
968
    enc = ost->st->codec;
969
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
970
        frame_number = ost->frame_number;
971
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
972
        if (enc->flags&CODEC_FLAG_PSNR)
973
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
974

    
975
        fprintf(vstats_file,"f_size= %6d ", frame_size);
976
        /* compute pts value */
977
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
978
        if (ti1 < 0.01)
979
            ti1 = 0.01;
980

    
981
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
982
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
983
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
984
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
985
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
986
    }
987
}
988

    
989
static void print_report(AVFormatContext **output_files,
990
                         AVOutputStream **ost_table, int nb_ostreams,
991
                         int is_last_report)
992
{
993
    char buf[1024];
994
    AVOutputStream *ost;
995
    AVFormatContext *oc, *os;
996
    int64_t total_size;
997
    AVCodecContext *enc;
998
    int frame_number, vid, i;
999
    double bitrate, ti1, pts;
1000
    static int64_t last_time = -1;
1001
    static int qp_histogram[52];
1002

    
1003
    if (!is_last_report) {
1004
        int64_t cur_time;
1005
        /* display the report every 0.5 seconds */
1006
        cur_time = av_gettime();
1007
        if (last_time == -1) {
1008
            last_time = cur_time;
1009
            return;
1010
        }
1011
        if ((cur_time - last_time) < 500000)
1012
            return;
1013
        last_time = cur_time;
1014
    }
1015

    
1016

    
1017
    oc = output_files[0];
1018

    
1019
    total_size = url_fsize(oc->pb);
1020
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1021
        total_size= url_ftell(oc->pb);
1022

    
1023
    buf[0] = '\0';
1024
    ti1 = 1e10;
1025
    vid = 0;
1026
    for(i=0;i<nb_ostreams;i++) {
1027
        ost = ost_table[i];
1028
        os = output_files[ost->file_index];
1029
        enc = ost->st->codec;
1030
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1031
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1032
                     !ost->st->stream_copy ?
1033
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1034
        }
1035
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1036
            float t = (av_gettime()-timer_start) / 1000000.0;
1037

    
1038
            frame_number = ost->frame_number;
1039
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1040
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1041
                     !ost->st->stream_copy ?
1042
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1043
            if(is_last_report)
1044
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1045
            if(qp_hist){
1046
                int j;
1047
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1048
                if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1049
                    qp_histogram[qp]++;
1050
                for(j=0; j<32; j++)
1051
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1052
            }
1053
            if (enc->flags&CODEC_FLAG_PSNR){
1054
                int j;
1055
                double error, error_sum=0;
1056
                double scale, scale_sum=0;
1057
                char type[3]= {'Y','U','V'};
1058
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1059
                for(j=0; j<3; j++){
1060
                    if(is_last_report){
1061
                        error= enc->error[j];
1062
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1063
                    }else{
1064
                        error= enc->coded_frame->error[j];
1065
                        scale= enc->width*enc->height*255.0*255.0;
1066
                    }
1067
                    if(j) scale/=4;
1068
                    error_sum += error;
1069
                    scale_sum += scale;
1070
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1071
                }
1072
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1073
            }
1074
            vid = 1;
1075
        }
1076
        /* compute min output value */
1077
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1078
        if ((pts < ti1) && (pts > 0))
1079
            ti1 = pts;
1080
    }
1081
    if (ti1 < 0.01)
1082
        ti1 = 0.01;
1083

    
1084
    if (verbose || is_last_report) {
1085
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1086

    
1087
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1088
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1089
            (double)total_size / 1024, ti1, bitrate);
1090

    
1091
        if (verbose > 1)
1092
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1093
                  nb_frames_dup, nb_frames_drop);
1094

    
1095
        if (verbose >= 0)
1096
            fprintf(stderr, "%s    \r", buf);
1097

    
1098
        fflush(stderr);
1099
    }
1100

    
1101
    if (is_last_report && verbose >= 0){
1102
        int64_t raw= audio_size + video_size + extra_size;
1103
        fprintf(stderr, "\n");
1104
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1105
                video_size/1024.0,
1106
                audio_size/1024.0,
1107
                extra_size/1024.0,
1108
                100.0*(total_size - raw)/raw
1109
        );
1110
    }
1111
}
1112

    
1113
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1114
static int output_packet(AVInputStream *ist, int ist_index,
1115
                         AVOutputStream **ost_table, int nb_ostreams,
1116
                         const AVPacket *pkt)
1117
{
1118
    AVFormatContext *os;
1119
    AVOutputStream *ost;
1120
    uint8_t *ptr;
1121
    int len, ret, i;
1122
    uint8_t *data_buf;
1123
    int data_size, got_picture;
1124
    AVFrame picture;
1125
    void *buffer_to_free;
1126
    static unsigned int samples_size= 0;
1127
    static short *samples= NULL;
1128
    AVSubtitle subtitle, *subtitle_to_free;
1129
    int got_subtitle;
1130

    
1131
    if(ist->next_pts == AV_NOPTS_VALUE)
1132
        ist->next_pts= ist->pts;
1133

    
1134
    if (pkt == NULL) {
1135
        /* EOF handling */
1136
        ptr = NULL;
1137
        len = 0;
1138
        goto handle_eof;
1139
    }
1140

    
1141
    if(pkt->dts != AV_NOPTS_VALUE)
1142
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1143

    
1144
    len = pkt->size;
1145
    ptr = pkt->data;
1146

    
1147
    //while we have more to decode or while the decoder did output something on EOF
1148
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1149
    handle_eof:
1150
        ist->pts= ist->next_pts;
1151

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

    
1155
        /* decode the packet if needed */
1156
        data_buf = NULL; /* fail safe */
1157
        data_size = 0;
1158
        subtitle_to_free = NULL;
1159
        if (ist->decoding_needed) {
1160
            switch(ist->st->codec->codec_type) {
1161
            case CODEC_TYPE_AUDIO:{
1162
                if(pkt)
1163
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1164
                data_size= samples_size;
1165
                    /* XXX: could avoid copy if PCM 16 bits with same
1166
                       endianness as CPU */
1167
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1168
                                           ptr, len);
1169
                if (ret < 0)
1170
                    goto fail_decode;
1171
                ptr += ret;
1172
                len -= ret;
1173
                /* Some bug in mpeg audio decoder gives */
1174
                /* data_size < 0, it seems they are overflows */
1175
                if (data_size <= 0) {
1176
                    /* no audio frame */
1177
                    continue;
1178
                }
1179
                data_buf = (uint8_t *)samples;
1180
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1181
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1182
                break;}
1183
            case CODEC_TYPE_VIDEO:
1184
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1185
                    /* XXX: allocate picture correctly */
1186
                    avcodec_get_frame_defaults(&picture);
1187

    
1188
                    ret = avcodec_decode_video(ist->st->codec,
1189
                                               &picture, &got_picture, ptr, len);
1190
                    ist->st->quality= picture.quality;
1191
                    if (ret < 0)
1192
                        goto fail_decode;
1193
                    if (!got_picture) {
1194
                        /* no picture yet */
1195
                        goto discard_packet;
1196
                    }
1197
                    if (ist->st->codec->time_base.num != 0) {
1198
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1199
                                          ist->st->codec->time_base.num) /
1200
                            ist->st->codec->time_base.den;
1201
                    }
1202
                    len = 0;
1203
                    break;
1204
            case CODEC_TYPE_SUBTITLE:
1205
                ret = avcodec_decode_subtitle(ist->st->codec,
1206
                                              &subtitle, &got_subtitle, ptr, len);
1207
                if (ret < 0)
1208
                    goto fail_decode;
1209
                if (!got_subtitle) {
1210
                    goto discard_packet;
1211
                }
1212
                subtitle_to_free = &subtitle;
1213
                len = 0;
1214
                break;
1215
            default:
1216
                goto fail_decode;
1217
            }
1218
        } else {
1219
            switch(ist->st->codec->codec_type) {
1220
            case CODEC_TYPE_AUDIO:
1221
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1222
                    ist->st->codec->sample_rate;
1223
                break;
1224
            case CODEC_TYPE_VIDEO:
1225
                if (ist->st->codec->time_base.num != 0) {
1226
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1227
                                      ist->st->codec->time_base.num) /
1228
                        ist->st->codec->time_base.den;
1229
                }
1230
                break;
1231
            }
1232
            data_buf = ptr;
1233
            data_size = len;
1234
            ret = len;
1235
            len = 0;
1236
        }
1237

    
1238
        buffer_to_free = NULL;
1239
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1240
            pre_process_video_frame(ist, (AVPicture *)&picture,
1241
                                    &buffer_to_free);
1242
        }
1243

    
1244
        // preprocess audio (volume)
1245
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1246
            if (audio_volume != 256) {
1247
                short *volp;
1248
                volp = samples;
1249
                for(i=0;i<(data_size / sizeof(short));i++) {
1250
                    int v = ((*volp) * audio_volume + 128) >> 8;
1251
                    if (v < -32768) v = -32768;
1252
                    if (v >  32767) v = 32767;
1253
                    *volp++ = v;
1254
                }
1255
            }
1256
        }
1257

    
1258
        /* frame rate emulation */
1259
        if (ist->st->codec->rate_emu) {
1260
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1261
            int64_t now = av_gettime() - ist->start;
1262
            if (pts > now)
1263
                usleep(pts - now);
1264

    
1265
            ist->frame++;
1266
        }
1267

    
1268
#if 0
1269
        /* mpeg PTS deordering : if it is a P or I frame, the PTS
1270
           is the one of the next displayed one */
1271
        /* XXX: add mpeg4 too ? */
1272
        if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1273
            if (ist->st->codec->pict_type != B_TYPE) {
1274
                int64_t tmp;
1275
                tmp = ist->last_ip_pts;
1276
                ist->last_ip_pts  = ist->frac_pts.val;
1277
                ist->frac_pts.val = tmp;
1278
            }
1279
        }
1280
#endif
1281
        /* if output time reached then transcode raw format,
1282
           encode packets and output them */
1283
        if (start_time == 0 || ist->pts >= start_time)
1284
            for(i=0;i<nb_ostreams;i++) {
1285
                int frame_size;
1286

    
1287
                ost = ost_table[i];
1288
                if (ost->source_index == ist_index) {
1289
                    os = output_files[ost->file_index];
1290

    
1291
#if 0
1292
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1293
                           (double)pkt->pts / AV_TIME_BASE,
1294
                           ((double)ist->pts / AV_TIME_BASE) -
1295
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1296
#endif
1297
                    /* set the input output pts pairs */
1298
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1299

    
1300
                    if (ost->encoding_needed) {
1301
                        switch(ost->st->codec->codec_type) {
1302
                        case CODEC_TYPE_AUDIO:
1303
                            do_audio_out(os, ost, ist, data_buf, data_size);
1304
                            break;
1305
                        case CODEC_TYPE_VIDEO:
1306
                            do_video_out(os, ost, ist, &picture, &frame_size);
1307
                            if (vstats_filename && frame_size)
1308
                                do_video_stats(os, ost, frame_size);
1309
                            break;
1310
                        case CODEC_TYPE_SUBTITLE:
1311
                            do_subtitle_out(os, ost, ist, &subtitle,
1312
                                            pkt->pts);
1313
                            break;
1314
                        default:
1315
                            abort();
1316
                        }
1317
                    } else {
1318
                        AVFrame avframe; //FIXME/XXX remove this
1319
                        AVPacket opkt;
1320
                        av_init_packet(&opkt);
1321

    
1322
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1323
                            continue;
1324

    
1325
                        /* no reencoding needed : output the packet directly */
1326
                        /* force the input stream PTS */
1327

    
1328
                        avcodec_get_frame_defaults(&avframe);
1329
                        ost->st->codec->coded_frame= &avframe;
1330
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1331

    
1332
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1333
                            audio_size += data_size;
1334
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1335
                            video_size += data_size;
1336
                            ost->sync_opts++;
1337
                        }
1338

    
1339
                        opkt.stream_index= ost->index;
1340
                        if(pkt->pts != AV_NOPTS_VALUE)
1341
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1342
                        else
1343
                            opkt.pts= AV_NOPTS_VALUE;
1344

    
1345
                        if (pkt->dts == AV_NOPTS_VALUE)
1346
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1347
                        else
1348
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1349

    
1350
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1351
                        opkt.flags= pkt->flags;
1352

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

    
1357
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1358
                        ost->st->codec->frame_number++;
1359
                        ost->frame_number++;
1360
                        av_free_packet(&opkt);
1361
                    }
1362
                }
1363
            }
1364
        av_free(buffer_to_free);
1365
        /* XXX: allocate the subtitles in the codec ? */
1366
        if (subtitle_to_free) {
1367
            if (subtitle_to_free->rects != NULL) {
1368
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1369
                    av_free(subtitle_to_free->rects[i].bitmap);
1370
                    av_free(subtitle_to_free->rects[i].rgba_palette);
1371
                }
1372
                av_freep(&subtitle_to_free->rects);
1373
            }
1374
            subtitle_to_free->num_rects = 0;
1375
            subtitle_to_free = NULL;
1376
        }
1377
    }
1378
 discard_packet:
1379
    if (pkt == NULL) {
1380
        /* EOF handling */
1381

    
1382
        for(i=0;i<nb_ostreams;i++) {
1383
            ost = ost_table[i];
1384
            if (ost->source_index == ist_index) {
1385
                AVCodecContext *enc= ost->st->codec;
1386
                os = output_files[ost->file_index];
1387

    
1388
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1389
                    continue;
1390
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1391
                    continue;
1392

    
1393
                if (ost->encoding_needed) {
1394
                    for(;;) {
1395
                        AVPacket pkt;
1396
                        int fifo_bytes;
1397
                        av_init_packet(&pkt);
1398
                        pkt.stream_index= ost->index;
1399

    
1400
                        switch(ost->st->codec->codec_type) {
1401
                        case CODEC_TYPE_AUDIO:
1402
                            fifo_bytes = av_fifo_size(&ost->fifo);
1403
                            ret = 0;
1404
                            /* encode any samples remaining in fifo */
1405
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1406
                                int fs_tmp = enc->frame_size;
1407
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1408
                                av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1409
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1410
                                enc->frame_size = fs_tmp;
1411
                            }
1412
                            if(ret <= 0) {
1413
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1414
                            }
1415
                            audio_size += ret;
1416
                            pkt.flags |= PKT_FLAG_KEY;
1417
                            break;
1418
                        case CODEC_TYPE_VIDEO:
1419
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1420
                            video_size += ret;
1421
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1422
                                pkt.flags |= PKT_FLAG_KEY;
1423
                            if (ost->logfile && enc->stats_out) {
1424
                                fprintf(ost->logfile, "%s", enc->stats_out);
1425
                            }
1426
                            break;
1427
                        default:
1428
                            ret=-1;
1429
                        }
1430

    
1431
                        if(ret<=0)
1432
                            break;
1433
                        pkt.data= bit_buffer;
1434
                        pkt.size= ret;
1435
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1436
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1437
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1438
                    }
1439
                }
1440
            }
1441
        }
1442
    }
1443

    
1444
    return 0;
1445
 fail_decode:
1446
    return -1;
1447
}
1448

    
1449
static void print_sdp(AVFormatContext **avc, int n)
1450
{
1451
    char sdp[2048];
1452

    
1453
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1454
    printf("SDP:\n%s\n", sdp);
1455
}
1456

    
1457
static int stream_index_from_inputs(AVFormatContext **input_files,
1458
                                    int nb_input_files,
1459
                                    AVInputFile *file_table,
1460
                                    AVInputStream **ist_table,
1461
                                    enum CodecType type,
1462
                                    int programid)
1463
{
1464
    int p, q, z;
1465
    for(z=0; z<nb_input_files; z++) {
1466
        AVFormatContext *ic = input_files[z];
1467
        for(p=0; p<ic->nb_programs; p++) {
1468
            AVProgram *program = ic->programs[p];
1469
            if(program->id != programid)
1470
                continue;
1471
            for(q=0; q<program->nb_stream_indexes; q++) {
1472
                int sidx = program->stream_index[q];
1473
                int ris = file_table[z].ist_index + sidx;
1474
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1475
                    return ris;
1476
            }
1477
        }
1478
    }
1479

    
1480
    return -1;
1481
}
1482

    
1483
/*
1484
 * The following code is the main loop of the file converter
1485
 */
1486
static int av_encode(AVFormatContext **output_files,
1487
                     int nb_output_files,
1488
                     AVFormatContext **input_files,
1489
                     int nb_input_files,
1490
                     AVStreamMap *stream_maps, int nb_stream_maps)
1491
{
1492
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1493
    AVFormatContext *is, *os;
1494
    AVCodecContext *codec, *icodec;
1495
    AVOutputStream *ost, **ost_table = NULL;
1496
    AVInputStream *ist, **ist_table = NULL;
1497
    AVInputFile *file_table;
1498
    int key;
1499
    int want_sdp = 1;
1500

    
1501
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1502
    if (!file_table)
1503
        goto fail;
1504

    
1505
    /* input stream init */
1506
    j = 0;
1507
    for(i=0;i<nb_input_files;i++) {
1508
        is = input_files[i];
1509
        file_table[i].ist_index = j;
1510
        file_table[i].nb_streams = is->nb_streams;
1511
        j += is->nb_streams;
1512
    }
1513
    nb_istreams = j;
1514

    
1515
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1516
    if (!ist_table)
1517
        goto fail;
1518

    
1519
    for(i=0;i<nb_istreams;i++) {
1520
        ist = av_mallocz(sizeof(AVInputStream));
1521
        if (!ist)
1522
            goto fail;
1523
        ist_table[i] = ist;
1524
    }
1525
    j = 0;
1526
    for(i=0;i<nb_input_files;i++) {
1527
        is = input_files[i];
1528
        for(k=0;k<is->nb_streams;k++) {
1529
            ist = ist_table[j++];
1530
            ist->st = is->streams[k];
1531
            ist->file_index = i;
1532
            ist->index = k;
1533
            ist->discard = 1; /* the stream is discarded by default
1534
                                 (changed later) */
1535

    
1536
            if (ist->st->codec->rate_emu) {
1537
                ist->start = av_gettime();
1538
                ist->frame = 0;
1539
            }
1540
        }
1541
    }
1542

    
1543
    /* output stream init */
1544
    nb_ostreams = 0;
1545
    for(i=0;i<nb_output_files;i++) {
1546
        os = output_files[i];
1547
        if (!os->nb_streams) {
1548
            fprintf(stderr, "Output file does not contain any stream\n");
1549
            av_exit(1);
1550
        }
1551
        nb_ostreams += os->nb_streams;
1552
    }
1553
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1554
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1555
        av_exit(1);
1556
    }
1557

    
1558
    /* Sanity check the mapping args -- do the input files & streams exist? */
1559
    for(i=0;i<nb_stream_maps;i++) {
1560
        int fi = stream_maps[i].file_index;
1561
        int si = stream_maps[i].stream_index;
1562

    
1563
        if (fi < 0 || fi > nb_input_files - 1 ||
1564
            si < 0 || si > file_table[fi].nb_streams - 1) {
1565
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1566
            av_exit(1);
1567
        }
1568
        fi = stream_maps[i].sync_file_index;
1569
        si = stream_maps[i].sync_stream_index;
1570
        if (fi < 0 || fi > nb_input_files - 1 ||
1571
            si < 0 || si > file_table[fi].nb_streams - 1) {
1572
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1573
            av_exit(1);
1574
        }
1575
    }
1576

    
1577
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1578
    if (!ost_table)
1579
        goto fail;
1580
    for(i=0;i<nb_ostreams;i++) {
1581
        ost = av_mallocz(sizeof(AVOutputStream));
1582
        if (!ost)
1583
            goto fail;
1584
        ost_table[i] = ost;
1585
    }
1586

    
1587
    n = 0;
1588
    for(k=0;k<nb_output_files;k++) {
1589
        os = output_files[k];
1590
        for(i=0;i<os->nb_streams;i++) {
1591
            int found;
1592
            ost = ost_table[n++];
1593
            ost->file_index = k;
1594
            ost->index = i;
1595
            ost->st = os->streams[i];
1596
            if (nb_stream_maps > 0) {
1597
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1598
                    stream_maps[n-1].stream_index;
1599

    
1600
                /* Sanity check that the stream types match */
1601
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1602
                    int i= ost->file_index;
1603
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1604
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1605
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1606
                        ost->file_index, ost->index);
1607
                    av_exit(1);
1608
                }
1609

    
1610
            } else {
1611
                if(opt_programid) {
1612
                    found = 0;
1613
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1614
                    if(j != -1) {
1615
                        ost->source_index = j;
1616
                        found = 1;
1617
                    }
1618
                } else {
1619
                    /* get corresponding input stream index : we select the first one with the right type */
1620
                    found = 0;
1621
                    for(j=0;j<nb_istreams;j++) {
1622
                        ist = ist_table[j];
1623
                        if (ist->discard &&
1624
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1625
                            ost->source_index = j;
1626
                            found = 1;
1627
                            break;
1628
                        }
1629
                    }
1630
                }
1631

    
1632
                if (!found) {
1633
                    if(! opt_programid) {
1634
                        /* try again and reuse existing stream */
1635
                        for(j=0;j<nb_istreams;j++) {
1636
                            ist = ist_table[j];
1637
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1638
                                ost->source_index = j;
1639
                                found = 1;
1640
                            }
1641
                        }
1642
                    }
1643
                    if (!found) {
1644
                        int i= ost->file_index;
1645
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1646
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1647
                                ost->file_index, ost->index);
1648
                        av_exit(1);
1649
                    }
1650
                }
1651
            }
1652
            ist = ist_table[ost->source_index];
1653
            ist->discard = 0;
1654
            ost->sync_ist = (nb_stream_maps > 0) ?
1655
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1656
                         stream_maps[n-1].sync_stream_index] : ist;
1657
        }
1658
    }
1659

    
1660
    /* for each output stream, we compute the right encoding parameters */
1661
    for(i=0;i<nb_ostreams;i++) {
1662
        ost = ost_table[i];
1663
        os = output_files[ost->file_index];
1664
        ist = ist_table[ost->source_index];
1665

    
1666
        codec = ost->st->codec;
1667
        icodec = ist->st->codec;
1668

    
1669
        if (!ost->st->language[0])
1670
            av_strlcpy(ost->st->language, ist->st->language,
1671
                       sizeof(ost->st->language));
1672

    
1673
        ost->st->disposition = ist->st->disposition;
1674

    
1675
        if (ost->st->stream_copy) {
1676
            /* if stream_copy is selected, no need to decode or encode */
1677
            codec->codec_id = icodec->codec_id;
1678
            codec->codec_type = icodec->codec_type;
1679

    
1680
            if(!codec->codec_tag){
1681
                if(   !os->oformat->codec_tag
1682
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1683
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1684
                    codec->codec_tag = icodec->codec_tag;
1685
            }
1686

    
1687
            codec->bit_rate = icodec->bit_rate;
1688
            codec->extradata= icodec->extradata;
1689
            codec->extradata_size= icodec->extradata_size;
1690
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1691
                codec->time_base = icodec->time_base;
1692
            else
1693
                codec->time_base = ist->st->time_base;
1694
            switch(codec->codec_type) {
1695
            case CODEC_TYPE_AUDIO:
1696
                if(audio_volume != 256) {
1697
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1698
                    av_exit(1);
1699
                }
1700
                codec->sample_rate = icodec->sample_rate;
1701
                codec->channels = icodec->channels;
1702
                codec->frame_size = icodec->frame_size;
1703
                codec->block_align= icodec->block_align;
1704
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1705
                    codec->block_align= 0;
1706
                if(codec->codec_id == CODEC_ID_AC3)
1707
                    codec->block_align= 0;
1708
                break;
1709
            case CODEC_TYPE_VIDEO:
1710
                if(using_vhook) {
1711
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1712
                    av_exit(1);
1713
                }
1714
                codec->pix_fmt = icodec->pix_fmt;
1715
                codec->width = icodec->width;
1716
                codec->height = icodec->height;
1717
                codec->has_b_frames = icodec->has_b_frames;
1718
                break;
1719
            case CODEC_TYPE_SUBTITLE:
1720
                break;
1721
            default:
1722
                abort();
1723
            }
1724
        } else {
1725
            switch(codec->codec_type) {
1726
            case CODEC_TYPE_AUDIO:
1727
                if (av_fifo_init(&ost->fifo, 1024))
1728
                    goto fail;
1729
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1730
                icodec->request_channels = codec->channels;
1731
                ist->decoding_needed = 1;
1732
                ost->encoding_needed = 1;
1733
                break;
1734
            case CODEC_TYPE_VIDEO:
1735
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1736
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1737
                ost->video_resample = ((codec->width != icodec->width -
1738
                                (frame_leftBand + frame_rightBand) +
1739
                                (frame_padleft + frame_padright)) ||
1740
                        (codec->height != icodec->height -
1741
                                (frame_topBand  + frame_bottomBand) +
1742
                                (frame_padtop + frame_padbottom)) ||
1743
                        (codec->pix_fmt != icodec->pix_fmt));
1744
                if (ost->video_crop) {
1745
                    ost->topBand = frame_topBand;
1746
                    ost->leftBand = frame_leftBand;
1747
                }
1748
                if (ost->video_pad) {
1749
                    ost->padtop = frame_padtop;
1750
                    ost->padleft = frame_padleft;
1751
                    ost->padbottom = frame_padbottom;
1752
                    ost->padright = frame_padright;
1753
                    if (!ost->video_resample) {
1754
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1755
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1756
                                         codec->width, codec->height))
1757
                            goto fail;
1758
                    }
1759
                }
1760
                if (ost->video_resample) {
1761
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1762
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1763
                                         codec->width, codec->height)) {
1764
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1765
                        av_exit(1);
1766
                    }
1767
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1768
                    ost->img_resample_ctx = sws_getContext(
1769
                            icodec->width - (frame_leftBand + frame_rightBand),
1770
                            icodec->height - (frame_topBand + frame_bottomBand),
1771
                            icodec->pix_fmt,
1772
                            codec->width - (frame_padleft + frame_padright),
1773
                            codec->height - (frame_padtop + frame_padbottom),
1774
                            codec->pix_fmt,
1775
                            sws_flags, NULL, NULL, NULL);
1776
                    if (ost->img_resample_ctx == NULL) {
1777
                        fprintf(stderr, "Cannot get resampling context\n");
1778
                        av_exit(1);
1779
                    }
1780
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1781
                }
1782
                ost->encoding_needed = 1;
1783
                ist->decoding_needed = 1;
1784
                break;
1785
            case CODEC_TYPE_SUBTITLE:
1786
                ost->encoding_needed = 1;
1787
                ist->decoding_needed = 1;
1788
                break;
1789
            default:
1790
                abort();
1791
                break;
1792
            }
1793
            /* two pass mode */
1794
            if (ost->encoding_needed &&
1795
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1796
                char logfilename[1024];
1797
                FILE *f;
1798
                int size;
1799
                char *logbuffer;
1800

    
1801
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1802
                         pass_logfilename ?
1803
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1804
                if (codec->flags & CODEC_FLAG_PASS1) {
1805
                    f = fopen(logfilename, "w");
1806
                    if (!f) {
1807
                        perror(logfilename);
1808
                        av_exit(1);
1809
                    }
1810
                    ost->logfile = f;
1811
                } else {
1812
                    /* read the log file */
1813
                    f = fopen(logfilename, "r");
1814
                    if (!f) {
1815
                        perror(logfilename);
1816
                        av_exit(1);
1817
                    }
1818
                    fseek(f, 0, SEEK_END);
1819
                    size = ftell(f);
1820
                    fseek(f, 0, SEEK_SET);
1821
                    logbuffer = av_malloc(size + 1);
1822
                    if (!logbuffer) {
1823
                        fprintf(stderr, "Could not allocate log buffer\n");
1824
                        av_exit(1);
1825
                    }
1826
                    size = fread(logbuffer, 1, size, f);
1827
                    fclose(f);
1828
                    logbuffer[size] = '\0';
1829
                    codec->stats_in = logbuffer;
1830
                }
1831
            }
1832
        }
1833
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1834
            int size= codec->width * codec->height;
1835
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1836
        }
1837
    }
1838

    
1839
    if (!bit_buffer)
1840
        bit_buffer = av_malloc(bit_buffer_size);
1841
    if (!bit_buffer)
1842
        goto fail;
1843

    
1844
    /* dump the file output parameters - cannot be done before in case
1845
       of stream copy */
1846
    for(i=0;i<nb_output_files;i++) {
1847
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1848
    }
1849

    
1850
    /* dump the stream mapping */
1851
    if (verbose >= 0) {
1852
        fprintf(stderr, "Stream mapping:\n");
1853
        for(i=0;i<nb_ostreams;i++) {
1854
            ost = ost_table[i];
1855
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1856
                    ist_table[ost->source_index]->file_index,
1857
                    ist_table[ost->source_index]->index,
1858
                    ost->file_index,
1859
                    ost->index);
1860
            if (ost->sync_ist != ist_table[ost->source_index])
1861
                fprintf(stderr, " [sync #%d.%d]",
1862
                        ost->sync_ist->file_index,
1863
                        ost->sync_ist->index);
1864
            fprintf(stderr, "\n");
1865
        }
1866
    }
1867

    
1868
    /* open each encoder */
1869
    for(i=0;i<nb_ostreams;i++) {
1870
        ost = ost_table[i];
1871
        if (ost->encoding_needed) {
1872
            AVCodec *codec;
1873
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1874
            if (!codec) {
1875
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1876
                        ost->file_index, ost->index);
1877
                av_exit(1);
1878
            }
1879
            if (avcodec_open(ost->st->codec, codec) < 0) {
1880
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1881
                        ost->file_index, ost->index);
1882
                av_exit(1);
1883
            }
1884
            extra_size += ost->st->codec->extradata_size;
1885
        }
1886
    }
1887

    
1888
    /* open each decoder */
1889
    for(i=0;i<nb_istreams;i++) {
1890
        ist = ist_table[i];
1891
        if (ist->decoding_needed) {
1892
            AVCodec *codec;
1893
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1894
            if (!codec) {
1895
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1896
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1897
                av_exit(1);
1898
            }
1899
            if (avcodec_open(ist->st->codec, codec) < 0) {
1900
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1901
                        ist->file_index, ist->index);
1902
                av_exit(1);
1903
            }
1904
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1905
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1906
        }
1907
    }
1908

    
1909
    /* init pts */
1910
    for(i=0;i<nb_istreams;i++) {
1911
        ist = ist_table[i];
1912
        is = input_files[ist->file_index];
1913
        ist->pts = 0;
1914
        ist->next_pts = AV_NOPTS_VALUE;
1915
        ist->is_start = 1;
1916
    }
1917

    
1918
    /* set meta data information from input file if required */
1919
    for (i=0;i<nb_meta_data_maps;i++) {
1920
        AVFormatContext *out_file;
1921
        AVFormatContext *in_file;
1922

    
1923
        int out_file_index = meta_data_maps[i].out_file;
1924
        int in_file_index = meta_data_maps[i].in_file;
1925
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1926
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1927
            ret = AVERROR(EINVAL);
1928
            goto fail;
1929
        }
1930
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1931
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1932
            ret = AVERROR(EINVAL);
1933
            goto fail;
1934
        }
1935

    
1936
        out_file = output_files[out_file_index];
1937
        in_file = input_files[in_file_index];
1938

    
1939
        strcpy(out_file->title, in_file->title);
1940
        strcpy(out_file->author, in_file->author);
1941
        strcpy(out_file->copyright, in_file->copyright);
1942
        strcpy(out_file->comment, in_file->comment);
1943
        strcpy(out_file->album, in_file->album);
1944
        out_file->year = in_file->year;
1945
        out_file->track = in_file->track;
1946
        strcpy(out_file->genre, in_file->genre);
1947
    }
1948

    
1949
    /* open files and write file headers */
1950
    for(i=0;i<nb_output_files;i++) {
1951
        os = output_files[i];
1952
        if (av_write_header(os) < 0) {
1953
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1954
            ret = AVERROR(EINVAL);
1955
            goto fail;
1956
        }
1957
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
1958
            want_sdp = 0;
1959
        }
1960
    }
1961
    if (want_sdp) {
1962
        print_sdp(output_files, nb_output_files);
1963
    }
1964

    
1965
    if (!using_stdin && verbose >= 0) {
1966
        fprintf(stderr, "Press [q] to stop encoding\n");
1967
        url_set_interrupt_cb(decode_interrupt_cb);
1968
    }
1969
    term_init();
1970

    
1971
    key = -1;
1972
    timer_start = av_gettime();
1973

    
1974
    for(; received_sigterm == 0;) {
1975
        int file_index, ist_index;
1976
        AVPacket pkt;
1977
        double ipts_min;
1978
        double opts_min;
1979

    
1980
    redo:
1981
        ipts_min= 1e100;
1982
        opts_min= 1e100;
1983
        /* if 'q' pressed, exits */
1984
        if (!using_stdin) {
1985
            if (q_pressed)
1986
                break;
1987
            /* read_key() returns 0 on EOF */
1988
            key = read_key();
1989
            if (key == 'q')
1990
                break;
1991
        }
1992

    
1993
        /* select the stream that we must read now by looking at the
1994
           smallest output pts */
1995
        file_index = -1;
1996
        for(i=0;i<nb_ostreams;i++) {
1997
            double ipts, opts;
1998
            ost = ost_table[i];
1999
            os = output_files[ost->file_index];
2000
            ist = ist_table[ost->source_index];
2001
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2002
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2003
            else
2004
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2005
            ipts = (double)ist->pts;
2006
            if (!file_table[ist->file_index].eof_reached){
2007
                if(ipts < ipts_min) {
2008
                    ipts_min = ipts;
2009
                    if(input_sync ) file_index = ist->file_index;
2010
                }
2011
                if(opts < opts_min) {
2012
                    opts_min = opts;
2013
                    if(!input_sync) file_index = ist->file_index;
2014
                }
2015
            }
2016
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2017
                file_index= -1;
2018
                break;
2019
            }
2020
        }
2021
        /* if none, if is finished */
2022
        if (file_index < 0) {
2023
            break;
2024
        }
2025

    
2026
        /* finish if recording time exhausted */
2027
        if (opts_min >= (recording_time / 1000000.0))
2028
            break;
2029

    
2030
        /* finish if limit size exhausted */
2031
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2032
            break;
2033

    
2034
        /* read a frame from it and output it in the fifo */
2035
        is = input_files[file_index];
2036
        if (av_read_frame(is, &pkt) < 0) {
2037
            file_table[file_index].eof_reached = 1;
2038
            if (opt_shortest)
2039
                break;
2040
            else
2041
                continue;
2042
        }
2043

    
2044
        if (do_pkt_dump) {
2045
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2046
        }
2047
        /* the following test is needed in case new streams appear
2048
           dynamically in stream : we ignore them */
2049
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2050
            goto discard_packet;
2051
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2052
        ist = ist_table[ist_index];
2053
        if (ist->discard)
2054
            goto discard_packet;
2055

    
2056
        if (pkt.dts != AV_NOPTS_VALUE)
2057
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2058
        if (pkt.pts != AV_NOPTS_VALUE)
2059
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2060

    
2061
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2062
            if(pkt.pts != AV_NOPTS_VALUE)
2063
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2064
            if(pkt.dts != AV_NOPTS_VALUE)
2065
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2066
        }
2067

    
2068
//        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);
2069
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2070
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2071
            int64_t delta= pkt_dts - ist->next_pts;
2072
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2073
                input_files_ts_offset[ist->file_index]-= delta;
2074
                if (verbose > 2)
2075
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2076
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2077
                if(pkt.pts != AV_NOPTS_VALUE)
2078
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2079
            }
2080
        }
2081

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

    
2085
            if (verbose >= 0)
2086
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2087
                        ist->file_index, ist->index);
2088

    
2089
            av_free_packet(&pkt);
2090
            goto redo;
2091
        }
2092

    
2093
    discard_packet:
2094
        av_free_packet(&pkt);
2095

    
2096
        /* dump report by using the output first video and audio streams */
2097
        print_report(output_files, ost_table, nb_ostreams, 0);
2098
    }
2099

    
2100
    /* at the end of stream, we must flush the decoder buffers */
2101
    for(i=0;i<nb_istreams;i++) {
2102
        ist = ist_table[i];
2103
        if (ist->decoding_needed) {
2104
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2105
        }
2106
    }
2107

    
2108
    term_exit();
2109

    
2110
    /* write the trailer if needed and close file */
2111
    for(i=0;i<nb_output_files;i++) {
2112
        os = output_files[i];
2113
        av_write_trailer(os);
2114
    }
2115

    
2116
    /* dump report by using the first video and audio streams */
2117
    print_report(output_files, ost_table, nb_ostreams, 1);
2118

    
2119
    /* close each encoder */
2120
    for(i=0;i<nb_ostreams;i++) {
2121
        ost = ost_table[i];
2122
        if (ost->encoding_needed) {
2123
            av_freep(&ost->st->codec->stats_in);
2124
            avcodec_close(ost->st->codec);
2125
        }
2126
    }
2127

    
2128
    /* close each decoder */
2129
    for(i=0;i<nb_istreams;i++) {
2130
        ist = ist_table[i];
2131
        if (ist->decoding_needed) {
2132
            avcodec_close(ist->st->codec);
2133
        }
2134
    }
2135

    
2136
    /* finished ! */
2137

    
2138
    ret = 0;
2139
 fail1:
2140
    av_freep(&bit_buffer);
2141
    av_free(file_table);
2142

    
2143
    if (ist_table) {
2144
        for(i=0;i<nb_istreams;i++) {
2145
            ist = ist_table[i];
2146
            av_free(ist);
2147
        }
2148
        av_free(ist_table);
2149
    }
2150
    if (ost_table) {
2151
        for(i=0;i<nb_ostreams;i++) {
2152
            ost = ost_table[i];
2153
            if (ost) {
2154
                if (ost->logfile) {
2155
                    fclose(ost->logfile);
2156
                    ost->logfile = NULL;
2157
                }
2158
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2159
                                             initialized but set to zero */
2160
                av_free(ost->pict_tmp.data[0]);
2161
                if (ost->video_resample)
2162
                    sws_freeContext(ost->img_resample_ctx);
2163
                if (ost->resample)
2164
                    audio_resample_close(ost->resample);
2165
                av_free(ost);
2166
            }
2167
        }
2168
        av_free(ost_table);
2169
    }
2170
    return ret;
2171
 fail:
2172
    ret = AVERROR(ENOMEM);
2173
    goto fail1;
2174
}
2175

    
2176
#if 0
2177
int file_read(const char *filename)
2178
{
2179
    URLContext *h;
2180
    unsigned char buffer[1024];
2181
    int len, i;
2182

2183
    if (url_open(&h, filename, O_RDONLY) < 0) {
2184
        printf("could not open '%s'\n", filename);
2185
        return -1;
2186
    }
2187
    for(;;) {
2188
        len = url_read(h, buffer, sizeof(buffer));
2189
        if (len <= 0)
2190
            break;
2191
        for(i=0;i<len;i++) putchar(buffer[i]);
2192
    }
2193
    url_close(h);
2194
    return 0;
2195
}
2196
#endif
2197

    
2198
static void opt_format(const char *arg)
2199
{
2200
    /* compatibility stuff for pgmyuv */
2201
    if (!strcmp(arg, "pgmyuv")) {
2202
        pgmyuv_compatibility_hack=1;
2203
//        opt_image_format(arg);
2204
        arg = "image2";
2205
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2206
    }
2207

    
2208
    file_iformat = av_find_input_format(arg);
2209
    file_oformat = guess_format(arg, NULL, NULL);
2210
    if (!file_iformat && !file_oformat) {
2211
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2212
        av_exit(1);
2213
    }
2214
}
2215

    
2216
static int opt_default(const char *opt, const char *arg){
2217
    int type;
2218
    const AVOption *o= NULL;
2219
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2220

    
2221
    for(type=0; type<CODEC_TYPE_NB; type++){
2222
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2223
        if(o2)
2224
            o = av_set_string2(avctx_opts[type], opt, arg, 1);
2225
    }
2226
    if(!o)
2227
        o = av_set_string2(avformat_opts, opt, arg, 1);
2228
    if(!o)
2229
        o = av_set_string2(sws_opts, opt, arg, 1);
2230
    if(!o){
2231
        if(opt[0] == 'a')
2232
            o = av_set_string2(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1);
2233
        else if(opt[0] == 'v')
2234
            o = av_set_string2(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1);
2235
        else if(opt[0] == 's')
2236
            o = av_set_string2(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1);
2237
    }
2238
    if(!o)
2239
        return -1;
2240

    
2241
//    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
2242

    
2243
    //FIXME we should always use avctx_opts, ... for storing options so there will not be any need to keep track of what i set over this
2244
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2245
    opt_names[opt_name_count++]= o->name;
2246

    
2247
    if(avctx_opts[0]->debug || avformat_opts->debug)
2248
        av_log_set_level(AV_LOG_DEBUG);
2249
    return 0;
2250
}
2251

    
2252
static void opt_video_rc_override_string(const char *arg)
2253
{
2254
    video_rc_override_string = arg;
2255
}
2256

    
2257
static int opt_me_threshold(const char *opt, const char *arg)
2258
{
2259
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2260
    return 0;
2261
}
2262

    
2263
static int opt_verbose(const char *opt, const char *arg)
2264
{
2265
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2266
    av_log_set_level(verbose);
2267
    return 0;
2268
}
2269

    
2270
static void opt_frame_rate(const char *arg)
2271
{
2272
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2273
        fprintf(stderr, "Incorrect frame rate\n");
2274
        av_exit(1);
2275
    }
2276
}
2277

    
2278
static int opt_bitrate(const char *opt, const char *arg)
2279
{
2280
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2281

    
2282
    opt_default(opt, arg);
2283

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

    
2287
    return 0;
2288
}
2289

    
2290
static void opt_frame_crop_top(const char *arg)
2291
{
2292
    frame_topBand = atoi(arg);
2293
    if (frame_topBand < 0) {
2294
        fprintf(stderr, "Incorrect top crop size\n");
2295
        av_exit(1);
2296
    }
2297
    if ((frame_topBand % 2) != 0) {
2298
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2299
        av_exit(1);
2300
    }
2301
    if ((frame_topBand) >= frame_height){
2302
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2303
        av_exit(1);
2304
    }
2305
    frame_height -= frame_topBand;
2306
}
2307

    
2308
static void opt_frame_crop_bottom(const char *arg)
2309
{
2310
    frame_bottomBand = atoi(arg);
2311
    if (frame_bottomBand < 0) {
2312
        fprintf(stderr, "Incorrect bottom crop size\n");
2313
        av_exit(1);
2314
    }
2315
    if ((frame_bottomBand % 2) != 0) {
2316
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2317
        av_exit(1);
2318
    }
2319
    if ((frame_bottomBand) >= frame_height){
2320
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2321
        av_exit(1);
2322
    }
2323
    frame_height -= frame_bottomBand;
2324
}
2325

    
2326
static void opt_frame_crop_left(const char *arg)
2327
{
2328
    frame_leftBand = atoi(arg);
2329
    if (frame_leftBand < 0) {
2330
        fprintf(stderr, "Incorrect left crop size\n");
2331
        av_exit(1);
2332
    }
2333
    if ((frame_leftBand % 2) != 0) {
2334
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2335
        av_exit(1);
2336
    }
2337
    if ((frame_leftBand) >= frame_width){
2338
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2339
        av_exit(1);
2340
    }
2341
    frame_width -= frame_leftBand;
2342
}
2343

    
2344
static void opt_frame_crop_right(const char *arg)
2345
{
2346
    frame_rightBand = atoi(arg);
2347
    if (frame_rightBand < 0) {
2348
        fprintf(stderr, "Incorrect right crop size\n");
2349
        av_exit(1);
2350
    }
2351
    if ((frame_rightBand % 2) != 0) {
2352
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2353
        av_exit(1);
2354
    }
2355
    if ((frame_rightBand) >= frame_width){
2356
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2357
        av_exit(1);
2358
    }
2359
    frame_width -= frame_rightBand;
2360
}
2361

    
2362
static void opt_frame_size(const char *arg)
2363
{
2364
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2365
        fprintf(stderr, "Incorrect frame size\n");
2366
        av_exit(1);
2367
    }
2368
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2369
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2370
        av_exit(1);
2371
    }
2372
}
2373

    
2374

    
2375
#define SCALEBITS 10
2376
#define ONE_HALF  (1 << (SCALEBITS - 1))
2377
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2378

    
2379
#define RGB_TO_Y(r, g, b) \
2380
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2381
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2382

    
2383
#define RGB_TO_U(r1, g1, b1, shift)\
2384
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2385
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2386

    
2387
#define RGB_TO_V(r1, g1, b1, shift)\
2388
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2389
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2390

    
2391
static void opt_pad_color(const char *arg) {
2392
    /* Input is expected to be six hex digits similar to
2393
       how colors are expressed in html tags (but without the #) */
2394
    int rgb = strtol(arg, NULL, 16);
2395
    int r,g,b;
2396

    
2397
    r = (rgb >> 16);
2398
    g = ((rgb >> 8) & 255);
2399
    b = (rgb & 255);
2400

    
2401
    padcolor[0] = RGB_TO_Y(r,g,b);
2402
    padcolor[1] = RGB_TO_U(r,g,b,0);
2403
    padcolor[2] = RGB_TO_V(r,g,b,0);
2404
}
2405

    
2406
static void opt_frame_pad_top(const char *arg)
2407
{
2408
    frame_padtop = atoi(arg);
2409
    if (frame_padtop < 0) {
2410
        fprintf(stderr, "Incorrect top pad size\n");
2411
        av_exit(1);
2412
    }
2413
    if ((frame_padtop % 2) != 0) {
2414
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2415
        av_exit(1);
2416
    }
2417
}
2418

    
2419
static void opt_frame_pad_bottom(const char *arg)
2420
{
2421
    frame_padbottom = atoi(arg);
2422
    if (frame_padbottom < 0) {
2423
        fprintf(stderr, "Incorrect bottom pad size\n");
2424
        av_exit(1);
2425
    }
2426
    if ((frame_padbottom % 2) != 0) {
2427
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2428
        av_exit(1);
2429
    }
2430
}
2431

    
2432

    
2433
static void opt_frame_pad_left(const char *arg)
2434
{
2435
    frame_padleft = atoi(arg);
2436
    if (frame_padleft < 0) {
2437
        fprintf(stderr, "Incorrect left pad size\n");
2438
        av_exit(1);
2439
    }
2440
    if ((frame_padleft % 2) != 0) {
2441
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2442
        av_exit(1);
2443
    }
2444
}
2445

    
2446

    
2447
static void opt_frame_pad_right(const char *arg)
2448
{
2449
    frame_padright = atoi(arg);
2450
    if (frame_padright < 0) {
2451
        fprintf(stderr, "Incorrect right pad size\n");
2452
        av_exit(1);
2453
    }
2454
    if ((frame_padright % 2) != 0) {
2455
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2456
        av_exit(1);
2457
    }
2458
}
2459

    
2460
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2461
{
2462
    int i;
2463
    char fmt_str[128];
2464
    for (i=-1; i < nb_fmts; i++) {
2465
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2466
        fprintf(stdout, "%s\n", fmt_str);
2467
    }
2468
}
2469

    
2470
static void opt_frame_pix_fmt(const char *arg)
2471
{
2472
    if (strcmp(arg, "list"))
2473
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2474
    else {
2475
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2476
        av_exit(0);
2477
    }
2478
}
2479

    
2480
static void opt_frame_aspect_ratio(const char *arg)
2481
{
2482
    int x = 0, y = 0;
2483
    double ar = 0;
2484
    const char *p;
2485
    char *end;
2486

    
2487
    p = strchr(arg, ':');
2488
    if (p) {
2489
        x = strtol(arg, &end, 10);
2490
        if (end == p)
2491
            y = strtol(end+1, &end, 10);
2492
        if (x > 0 && y > 0)
2493
            ar = (double)x / (double)y;
2494
    } else
2495
        ar = strtod(arg, NULL);
2496

    
2497
    if (!ar) {
2498
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2499
        av_exit(1);
2500
    }
2501
    frame_aspect_ratio = ar;
2502
}
2503

    
2504
static void opt_qscale(const char *arg)
2505
{
2506
    video_qscale = atof(arg);
2507
    if (video_qscale <= 0 ||
2508
        video_qscale > 255) {
2509
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2510
        av_exit(1);
2511
    }
2512
}
2513

    
2514
static void opt_top_field_first(const char *arg)
2515
{
2516
    top_field_first= atoi(arg);
2517
}
2518

    
2519
static int opt_thread_count(const char *opt, const char *arg)
2520
{
2521
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2522
#if !defined(HAVE_THREADS)
2523
    if (verbose >= 0)
2524
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2525
#endif
2526
    return 0;
2527
}
2528

    
2529
static void opt_audio_sample_fmt(const char *arg)
2530
{
2531
    if (strcmp(arg, "list"))
2532
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2533
    else {
2534
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2535
        av_exit(0);
2536
    }
2537
}
2538

    
2539
static int opt_audio_rate(const char *opt, const char *arg)
2540
{
2541
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2542
    return 0;
2543
}
2544

    
2545
static int opt_audio_channels(const char *opt, const char *arg)
2546
{
2547
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2548
    return 0;
2549
}
2550

    
2551
static void opt_video_channel(const char *arg)
2552
{
2553
    video_channel = strtol(arg, NULL, 0);
2554
}
2555

    
2556
static void opt_video_standard(const char *arg)
2557
{
2558
    video_standard = av_strdup(arg);
2559
}
2560

    
2561
static void opt_codec(int *pstream_copy, char **pcodec_name,
2562
                      int codec_type, const char *arg)
2563
{
2564
    av_freep(pcodec_name);
2565
    if (!strcmp(arg, "copy")) {
2566
        *pstream_copy = 1;
2567
    } else {
2568
        *pcodec_name = av_strdup(arg);
2569
    }
2570
}
2571

    
2572
static void opt_audio_codec(const char *arg)
2573
{
2574
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2575
}
2576

    
2577
static void opt_audio_tag(const char *arg)
2578
{
2579
    char *tail;
2580
    audio_codec_tag= strtol(arg, &tail, 0);
2581

    
2582
    if(!tail || *tail)
2583
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2584
}
2585

    
2586
static void opt_video_tag(const char *arg)
2587
{
2588
    char *tail;
2589
    video_codec_tag= strtol(arg, &tail, 0);
2590

    
2591
    if(!tail || *tail)
2592
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2593
}
2594

    
2595
#ifdef CONFIG_VHOOK
2596
static void add_frame_hooker(const char *arg)
2597
{
2598
    int argc = 0;
2599
    char *argv[64];
2600
    int i;
2601
    char *args = av_strdup(arg);
2602

    
2603
    using_vhook = 1;
2604

    
2605
    argv[0] = strtok(args, " ");
2606
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2607
    }
2608

    
2609
    i = frame_hook_add(argc, argv);
2610

    
2611
    if (i != 0) {
2612
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2613
        av_exit(1);
2614
    }
2615
}
2616
#endif
2617

    
2618
static void opt_video_codec(const char *arg)
2619
{
2620
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2621
}
2622

    
2623
static void opt_subtitle_codec(const char *arg)
2624
{
2625
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2626
}
2627

    
2628
static void opt_map(const char *arg)
2629
{
2630
    AVStreamMap *m;
2631
    char *p;
2632

    
2633
    m = &stream_maps[nb_stream_maps++];
2634

    
2635
    m->file_index = strtol(arg, &p, 0);
2636
    if (*p)
2637
        p++;
2638

    
2639
    m->stream_index = strtol(p, &p, 0);
2640
    if (*p) {
2641
        p++;
2642
        m->sync_file_index = strtol(p, &p, 0);
2643
        if (*p)
2644
            p++;
2645
        m->sync_stream_index = strtol(p, &p, 0);
2646
    } else {
2647
        m->sync_file_index = m->file_index;
2648
        m->sync_stream_index = m->stream_index;
2649
    }
2650
}
2651

    
2652
static void opt_map_meta_data(const char *arg)
2653
{
2654
    AVMetaDataMap *m;
2655
    char *p;
2656

    
2657
    m = &meta_data_maps[nb_meta_data_maps++];
2658

    
2659
    m->out_file = strtol(arg, &p, 0);
2660
    if (*p)
2661
        p++;
2662

    
2663
    m->in_file = strtol(p, &p, 0);
2664
}
2665

    
2666
static void opt_input_ts_scale(const char *arg)
2667
{
2668
    unsigned int stream;
2669
    double scale;
2670
    char *p;
2671

    
2672
    stream = strtol(arg, &p, 0);
2673
    if (*p)
2674
        p++;
2675
    scale= strtod(p, &p);
2676

    
2677
    if(stream >= MAX_STREAMS)
2678
        av_exit(1);
2679

    
2680
    input_files_ts_scale[nb_input_files][stream]= scale;
2681
}
2682

    
2683
static int opt_recording_time(const char *opt, const char *arg)
2684
{
2685
    recording_time = parse_time_or_die(opt, arg, 1);
2686
    return 0;
2687
}
2688

    
2689
static int opt_start_time(const char *opt, const char *arg)
2690
{
2691
    start_time = parse_time_or_die(opt, arg, 1);
2692
    return 0;
2693
}
2694

    
2695
static int opt_rec_timestamp(const char *opt, const char *arg)
2696
{
2697
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2698
    return 0;
2699
}
2700

    
2701
static int opt_input_ts_offset(const char *opt, const char *arg)
2702
{
2703
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2704
    return 0;
2705
}
2706

    
2707
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2708
{
2709
    const char *codec_string = encoder ? "encoder" : "decoder";
2710
    AVCodec *codec;
2711

    
2712
    if(!name)
2713
        return CODEC_ID_NONE;
2714
    codec = encoder ?
2715
        avcodec_find_encoder_by_name(name) :
2716
        avcodec_find_decoder_by_name(name);
2717
    if(!codec) {
2718
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2719
        av_exit(1);
2720
    }
2721
    if(codec->type != type) {
2722
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2723
        av_exit(1);
2724
    }
2725
    return codec->id;
2726
}
2727

    
2728
static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2729
{
2730
    int i;
2731
    for(i=0; i<opt_name_count; i++){
2732
        char buf[256];
2733
        const AVOption *opt;
2734
        const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2735
        /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2736
        if(str && ((opt->flags & flags) == flags))
2737
            av_set_string2(ctx, opt_names[i], str, 1);
2738
    }
2739
}
2740

    
2741
static void opt_input_file(const char *filename)
2742
{
2743
    AVFormatContext *ic;
2744
    AVFormatParameters params, *ap = &params;
2745
    int err, i, ret, rfps, rfps_base;
2746
    int64_t timestamp;
2747

    
2748
    if (!strcmp(filename, "-"))
2749
        filename = "pipe:";
2750

    
2751
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2752
                    !strcmp(filename, "/dev/stdin");
2753

    
2754
    /* get default parameters from command line */
2755
    ic = av_alloc_format_context();
2756

    
2757
    memset(ap, 0, sizeof(*ap));
2758
    ap->prealloced_context = 1;
2759
    ap->sample_rate = audio_sample_rate;
2760
    ap->channels = audio_channels;
2761
    ap->time_base.den = frame_rate.num;
2762
    ap->time_base.num = frame_rate.den;
2763
    ap->width = frame_width + frame_padleft + frame_padright;
2764
    ap->height = frame_height + frame_padtop + frame_padbottom;
2765
    ap->pix_fmt = frame_pix_fmt;
2766
    ap->channel = video_channel;
2767
    ap->standard = video_standard;
2768
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2769
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2770
    if(pgmyuv_compatibility_hack)
2771
        ap->video_codec_id= CODEC_ID_PGMYUV;
2772

    
2773
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2774

    
2775
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2776
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2777
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2778

    
2779
    /* open the input file with generic libav function */
2780
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2781
    if (err < 0) {
2782
        print_error(filename, err);
2783
        av_exit(1);
2784
    }
2785
    if(opt_programid) {
2786
        int i;
2787
        for(i=0; i<ic->nb_programs; i++)
2788
            if(ic->programs[i]->id != opt_programid)
2789
                ic->programs[i]->discard = AVDISCARD_ALL;
2790
    }
2791

    
2792
    ic->loop_input = loop_input;
2793

    
2794
    /* If not enough info to get the stream parameters, we decode the
2795
       first frames to get it. (used in mpeg case for example) */
2796
    ret = av_find_stream_info(ic);
2797
    if (ret < 0 && verbose >= 0) {
2798
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2799
        av_exit(1);
2800
    }
2801

    
2802
    timestamp = start_time;
2803
    /* add the stream start time */
2804
    if (ic->start_time != AV_NOPTS_VALUE)
2805
        timestamp += ic->start_time;
2806

    
2807
    /* if seeking requested, we execute it */
2808
    if (start_time != 0) {
2809
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2810
        if (ret < 0) {
2811
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2812
                    filename, (double)timestamp / AV_TIME_BASE);
2813
        }
2814
        /* reset seek info */
2815
        start_time = 0;
2816
    }
2817

    
2818
    /* update the current parameters so that they match the one of the input stream */
2819
    for(i=0;i<ic->nb_streams;i++) {
2820
        AVCodecContext *enc = ic->streams[i]->codec;
2821
        if(thread_count>1)
2822
            avcodec_thread_init(enc, thread_count);
2823
        enc->thread_count= thread_count;
2824
        switch(enc->codec_type) {
2825
        case CODEC_TYPE_AUDIO:
2826
            set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2827
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2828
            audio_channels = enc->channels;
2829
            audio_sample_rate = enc->sample_rate;
2830
            if(audio_disable)
2831
                ic->streams[i]->discard= AVDISCARD_ALL;
2832
            break;
2833
        case CODEC_TYPE_VIDEO:
2834
            set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2835
            frame_height = enc->height;
2836
            frame_width = enc->width;
2837
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2838
            frame_pix_fmt = enc->pix_fmt;
2839
            rfps      = ic->streams[i]->r_frame_rate.num;
2840
            rfps_base = ic->streams[i]->r_frame_rate.den;
2841
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2842
            if(me_threshold)
2843
                enc->debug |= FF_DEBUG_MV;
2844

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

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

    
2851
                    (float)rfps / rfps_base, rfps, rfps_base);
2852
            }
2853
            /* update the current frame rate to match the stream frame rate */
2854
            frame_rate.num = rfps;
2855
            frame_rate.den = rfps_base;
2856

    
2857
            enc->rate_emu = rate_emu;
2858
            if(video_disable)
2859
                ic->streams[i]->discard= AVDISCARD_ALL;
2860
            else if(video_discard)
2861
                ic->streams[i]->discard= video_discard;
2862
            break;
2863
        case CODEC_TYPE_DATA:
2864
            break;
2865
        case CODEC_TYPE_SUBTITLE:
2866
            if(subtitle_disable)
2867
                ic->streams[i]->discard = AVDISCARD_ALL;
2868
            break;
2869
        case CODEC_TYPE_ATTACHMENT:
2870
        case CODEC_TYPE_UNKNOWN:
2871
            break;
2872
        default:
2873
            abort();
2874
        }
2875
    }
2876

    
2877
    input_files[nb_input_files] = ic;
2878
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2879
    /* dump the file content */
2880
    if (verbose >= 0)
2881
        dump_format(ic, nb_input_files, filename, 0);
2882

    
2883
    nb_input_files++;
2884
    file_iformat = NULL;
2885
    file_oformat = NULL;
2886

    
2887
    video_channel = 0;
2888

    
2889
    rate_emu = 0;
2890
    av_freep(&video_codec_name);
2891
    av_freep(&audio_codec_name);
2892
    av_freep(&subtitle_codec_name);
2893
}
2894

    
2895
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2896
                                         int *has_subtitle_ptr)
2897
{
2898
    int has_video, has_audio, has_subtitle, i, j;
2899
    AVFormatContext *ic;
2900

    
2901
    has_video = 0;
2902
    has_audio = 0;
2903
    has_subtitle = 0;
2904
    for(j=0;j<nb_input_files;j++) {
2905
        ic = input_files[j];
2906
        for(i=0;i<ic->nb_streams;i++) {
2907
            AVCodecContext *enc = ic->streams[i]->codec;
2908
            switch(enc->codec_type) {
2909
            case CODEC_TYPE_AUDIO:
2910
                has_audio = 1;
2911
                break;
2912
            case CODEC_TYPE_VIDEO:
2913
                has_video = 1;
2914
                break;
2915
            case CODEC_TYPE_SUBTITLE:
2916
                has_subtitle = 1;
2917
                break;
2918
            case CODEC_TYPE_DATA:
2919
            case CODEC_TYPE_ATTACHMENT:
2920
            case CODEC_TYPE_UNKNOWN:
2921
                break;
2922
            default:
2923
                abort();
2924
            }
2925
        }
2926
    }
2927
    *has_video_ptr = has_video;
2928
    *has_audio_ptr = has_audio;
2929
    *has_subtitle_ptr = has_subtitle;
2930
}
2931

    
2932
static void new_video_stream(AVFormatContext *oc)
2933
{
2934
    AVStream *st;
2935
    AVCodecContext *video_enc;
2936
    int codec_id;
2937

    
2938
    st = av_new_stream(oc, oc->nb_streams);
2939
    if (!st) {
2940
        fprintf(stderr, "Could not alloc stream\n");
2941
        av_exit(1);
2942
    }
2943
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2944
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2945
    video_bitstream_filters= NULL;
2946

    
2947
    if(thread_count>1)
2948
        avcodec_thread_init(st->codec, thread_count);
2949

    
2950
    video_enc = st->codec;
2951

    
2952
    if(video_codec_tag)
2953
        video_enc->codec_tag= video_codec_tag;
2954

    
2955
    if(   (video_global_header&1)
2956
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2957
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2958
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2959
    }
2960
    if(video_global_header&2){
2961
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2962
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2963
    }
2964

    
2965
    if (video_stream_copy) {
2966
        st->stream_copy = 1;
2967
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2968
    } else {
2969
        const char *p;
2970
        int i;
2971
        AVCodec *codec;
2972
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2973

    
2974
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2975
        if (video_codec_name)
2976
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2977

    
2978
        video_enc->codec_id = codec_id;
2979
        codec = avcodec_find_encoder(codec_id);
2980

    
2981
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2982

    
2983
        video_enc->time_base.den = fps.num;
2984
        video_enc->time_base.num = fps.den;
2985
        if(codec && codec->supported_framerates){
2986
            const AVRational *p= codec->supported_framerates;
2987
            const AVRational *best=NULL;
2988
            AVRational best_error= (AVRational){INT_MAX, 1};
2989
            for(; p->den!=0; p++){
2990
                AVRational error= av_sub_q(fps, *p);
2991
                if(error.num <0) error.num *= -1;
2992
                if(av_cmp_q(error, best_error) < 0){
2993
                    best_error= error;
2994
                    best= p;
2995
                }
2996
            }
2997
            video_enc->time_base.den= best->num;
2998
            video_enc->time_base.num= best->den;
2999
        }
3000

    
3001
        video_enc->width = frame_width + frame_padright + frame_padleft;
3002
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3003
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3004
        video_enc->pix_fmt = frame_pix_fmt;
3005

    
3006
        if(codec && codec->pix_fmts){
3007
            const enum PixelFormat *p= codec->pix_fmts;
3008
            for(; *p!=-1; p++){
3009
                if(*p == video_enc->pix_fmt)
3010
                    break;
3011
            }
3012
            if(*p == -1)
3013
                video_enc->pix_fmt = codec->pix_fmts[0];
3014
        }
3015

    
3016
        if (intra_only)
3017
            video_enc->gop_size = 0;
3018
        if (video_qscale || same_quality) {
3019
            video_enc->flags |= CODEC_FLAG_QSCALE;
3020
            video_enc->global_quality=
3021
                st->quality = FF_QP2LAMBDA * video_qscale;
3022
        }
3023

    
3024
        if(intra_matrix)
3025
            video_enc->intra_matrix = intra_matrix;
3026
        if(inter_matrix)
3027
            video_enc->inter_matrix = inter_matrix;
3028

    
3029
        video_enc->thread_count = thread_count;
3030
        p= video_rc_override_string;
3031
        for(i=0; p; i++){
3032
            int start, end, q;
3033
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3034
            if(e!=3){
3035
                fprintf(stderr, "error parsing rc_override\n");
3036
                av_exit(1);
3037
            }
3038
            video_enc->rc_override=
3039
                av_realloc(video_enc->rc_override,
3040
                           sizeof(RcOverride)*(i+1));
3041
            video_enc->rc_override[i].start_frame= start;
3042
            video_enc->rc_override[i].end_frame  = end;
3043
            if(q>0){
3044
                video_enc->rc_override[i].qscale= q;
3045
                video_enc->rc_override[i].quality_factor= 1.0;
3046
            }
3047
            else{
3048
                video_enc->rc_override[i].qscale= 0;
3049
                video_enc->rc_override[i].quality_factor= -q/100.0;
3050
            }
3051
            p= strchr(p, '/');
3052
            if(p) p++;
3053
        }
3054
        video_enc->rc_override_count=i;
3055
        if (!video_enc->rc_initial_buffer_occupancy)
3056
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3057
        video_enc->me_threshold= me_threshold;
3058
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3059

    
3060
        if (do_psnr)
3061
            video_enc->flags|= CODEC_FLAG_PSNR;
3062

    
3063
        /* two pass mode */
3064
        if (do_pass) {
3065
            if (do_pass == 1) {
3066
                video_enc->flags |= CODEC_FLAG_PASS1;
3067
            } else {
3068
                video_enc->flags |= CODEC_FLAG_PASS2;
3069
            }
3070
        }
3071
    }
3072

    
3073
    /* reset some key parameters */
3074
    video_disable = 0;
3075
    av_freep(&video_codec_name);
3076
    video_stream_copy = 0;
3077
}
3078

    
3079
static void new_audio_stream(AVFormatContext *oc)
3080
{
3081
    AVStream *st;
3082
    AVCodecContext *audio_enc;
3083
    int codec_id;
3084

    
3085
    st = av_new_stream(oc, oc->nb_streams);
3086
    if (!st) {
3087
        fprintf(stderr, "Could not alloc stream\n");
3088
        av_exit(1);
3089
    }
3090
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3091

    
3092
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3093
    audio_bitstream_filters= NULL;
3094

    
3095
    if(thread_count>1)
3096
        avcodec_thread_init(st->codec, thread_count);
3097

    
3098
    audio_enc = st->codec;
3099
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3100

    
3101
    if(audio_codec_tag)
3102
        audio_enc->codec_tag= audio_codec_tag;
3103

    
3104
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3105
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3106
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3107
    }
3108
    if (audio_stream_copy) {
3109
        st->stream_copy = 1;
3110
        audio_enc->channels = audio_channels;
3111
    } else {
3112
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3113

    
3114
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3115

    
3116
        if (audio_codec_name)
3117
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3118
        audio_enc->codec_id = codec_id;
3119

    
3120
        if (audio_qscale > QSCALE_NONE) {
3121
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3122
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3123
        }
3124
        audio_enc->thread_count = thread_count;
3125
        audio_enc->channels = audio_channels;
3126
    }
3127
    audio_enc->sample_rate = audio_sample_rate;
3128
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3129
    if (audio_language) {
3130
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3131
        av_free(audio_language);
3132
        audio_language = NULL;
3133
    }
3134

    
3135
    /* reset some key parameters */
3136
    audio_disable = 0;
3137
    av_freep(&audio_codec_name);
3138
    audio_stream_copy = 0;
3139
}
3140

    
3141
static void new_subtitle_stream(AVFormatContext *oc)
3142
{
3143
    AVStream *st;
3144
    AVCodecContext *subtitle_enc;
3145

    
3146
    st = av_new_stream(oc, oc->nb_streams);
3147
    if (!st) {
3148
        fprintf(stderr, "Could not alloc stream\n");
3149
        av_exit(1);
3150
    }
3151
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3152

    
3153
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3154
    subtitle_bitstream_filters= NULL;
3155

    
3156
    subtitle_enc = st->codec;
3157
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3158
    if (subtitle_stream_copy) {
3159
        st->stream_copy = 1;
3160
    } else {
3161
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3162
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3163
    }
3164

    
3165
    if (subtitle_language) {
3166
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3167
        av_free(subtitle_language);
3168
        subtitle_language = NULL;
3169
    }
3170

    
3171
    subtitle_disable = 0;
3172
    av_freep(&subtitle_codec_name);
3173
    subtitle_stream_copy = 0;
3174
}
3175

    
3176
static void opt_new_audio_stream(void)
3177
{
3178
    AVFormatContext *oc;
3179
    if (nb_output_files <= 0) {
3180
        fprintf(stderr, "At least one output file must be specified\n");
3181
        av_exit(1);
3182
    }
3183
    oc = output_files[nb_output_files - 1];
3184
    new_audio_stream(oc);
3185
}
3186

    
3187
static void opt_new_video_stream(void)
3188
{
3189
    AVFormatContext *oc;
3190
    if (nb_output_files <= 0) {
3191
        fprintf(stderr, "At least one output file must be specified\n");
3192
        av_exit(1);
3193
    }
3194
    oc = output_files[nb_output_files - 1];
3195
    new_video_stream(oc);
3196
}
3197

    
3198
static void opt_new_subtitle_stream(void)
3199
{
3200
    AVFormatContext *oc;
3201
    if (nb_output_files <= 0) {
3202
        fprintf(stderr, "At least one output file must be specified\n");
3203
        av_exit(1);
3204
    }
3205
    oc = output_files[nb_output_files - 1];
3206
    new_subtitle_stream(oc);
3207
}
3208

    
3209
static void opt_output_file(const char *filename)
3210
{
3211
    AVFormatContext *oc;
3212
    int use_video, use_audio, use_subtitle;
3213
    int input_has_video, input_has_audio, input_has_subtitle;
3214
    AVFormatParameters params, *ap = &params;
3215

    
3216
    if (!strcmp(filename, "-"))
3217
        filename = "pipe:";
3218

    
3219
    oc = av_alloc_format_context();
3220

    
3221
    if (!file_oformat) {
3222
        file_oformat = guess_format(NULL, filename, NULL);
3223
        if (!file_oformat) {
3224
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3225
                    filename);
3226
            av_exit(1);
3227
        }
3228
    }
3229

    
3230
    oc->oformat = file_oformat;
3231
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3232

    
3233
    if (!strcmp(file_oformat->name, "ffm") &&
3234
        av_strstart(filename, "http:", NULL)) {
3235
        /* special case for files sent to ffserver: we get the stream
3236
           parameters from ffserver */
3237
        int err = read_ffserver_streams(oc, filename);
3238
        if (err < 0) {
3239
            print_error(filename, err);
3240
            av_exit(1);
3241
        }
3242
    } else {
3243
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3244
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3245
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3246

    
3247
        /* disable if no corresponding type found and at least one
3248
           input file */
3249
        if (nb_input_files > 0) {
3250
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3251
                                         &input_has_subtitle);
3252
            if (!input_has_video)
3253
                use_video = 0;
3254
            if (!input_has_audio)
3255
                use_audio = 0;
3256
            if (!input_has_subtitle)
3257
                use_subtitle = 0;
3258
        }
3259

    
3260
        /* manual disable */
3261
        if (audio_disable) {
3262
            use_audio = 0;
3263
        }
3264
        if (video_disable) {
3265
            use_video = 0;
3266
        }
3267
        if (subtitle_disable) {
3268
            use_subtitle = 0;
3269
        }
3270

    
3271
        if (use_video) {
3272
            new_video_stream(oc);
3273
        }
3274

    
3275
        if (use_audio) {
3276
            new_audio_stream(oc);
3277
        }
3278

    
3279
        if (use_subtitle) {
3280
            new_subtitle_stream(oc);
3281
        }
3282

    
3283
        oc->timestamp = rec_timestamp;
3284

    
3285
        if (str_title)
3286
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3287
        if (str_author)
3288
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3289
        if (str_copyright)
3290
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3291
        if (str_comment)
3292
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3293
        if (str_album)
3294
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3295
        if (str_genre)
3296
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3297
    }
3298

    
3299
    output_files[nb_output_files++] = oc;
3300

    
3301
    /* check filename in case of an image number is expected */
3302
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3303
        if (!av_filename_number_test(oc->filename)) {
3304
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3305
            av_exit(1);
3306
        }
3307
    }
3308

    
3309
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3310
        /* test if it already exists to avoid loosing precious files */
3311
        if (!file_overwrite &&
3312
            (strchr(filename, ':') == NULL ||
3313
             filename[1] == ':' ||
3314
             av_strstart(filename, "file:", NULL))) {
3315
            if (url_exist(filename)) {
3316
                int c;
3317

    
3318
                if (!using_stdin) {
3319
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3320
                    fflush(stderr);
3321
                    c = getchar();
3322
                    if (toupper(c) != 'Y') {
3323
                        fprintf(stderr, "Not overwriting - exiting\n");
3324
                        av_exit(1);
3325
                    }
3326
                }
3327
                else {
3328
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3329
                    av_exit(1);
3330
                }
3331
            }
3332
        }
3333

    
3334
        /* open the file */
3335
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3336
            fprintf(stderr, "Could not open '%s'\n", filename);
3337
            av_exit(1);
3338
        }
3339
    }
3340

    
3341
    memset(ap, 0, sizeof(*ap));
3342
    if (av_set_parameters(oc, ap) < 0) {
3343
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3344
                oc->filename);
3345
        av_exit(1);
3346
    }
3347

    
3348
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3349
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3350
    oc->loop_output = loop_output;
3351

    
3352
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3353

    
3354
    /* reset some options */
3355
    file_oformat = NULL;
3356
    file_iformat = NULL;
3357
}
3358

    
3359
/* same option as mencoder */
3360
static void opt_pass(const char *pass_str)
3361
{
3362
    int pass;
3363
    pass = atoi(pass_str);
3364
    if (pass != 1 && pass != 2) {
3365
        fprintf(stderr, "pass number can be only 1 or 2\n");
3366
        av_exit(1);
3367
    }
3368
    do_pass = pass;
3369
}
3370

    
3371
static int64_t getutime(void)
3372
{
3373
#ifdef HAVE_GETRUSAGE
3374
    struct rusage rusage;
3375

    
3376
    getrusage(RUSAGE_SELF, &rusage);
3377
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3378
#elif defined(HAVE_GETPROCESSTIMES)
3379
    HANDLE proc;
3380
    FILETIME c, e, k, u;
3381
    proc = GetCurrentProcess();
3382
    GetProcessTimes(proc, &c, &e, &k, &u);
3383
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3384
#else
3385
    return av_gettime();
3386
#endif
3387
}
3388

    
3389
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3390
{
3391
    int i;
3392
    const char *p = str;
3393
    for(i = 0;; i++) {
3394
        dest[i] = atoi(p);
3395
        if(i == 63)
3396
            break;
3397
        p = strchr(p, ',');
3398
        if(!p) {
3399
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3400
            av_exit(1);
3401
        }
3402
        p++;
3403
    }
3404
}
3405

    
3406
static void opt_inter_matrix(const char *arg)
3407
{
3408
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3409
    parse_matrix_coeffs(inter_matrix, arg);
3410
}
3411

    
3412
static void opt_intra_matrix(const char *arg)
3413
{
3414
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3415
    parse_matrix_coeffs(intra_matrix, arg);
3416
}
3417

    
3418
/**
3419
 * Trivial log callback.
3420
 * Only suitable for show_help and similar since it lacks prefix handling.
3421
 */
3422
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3423
{
3424
    vfprintf(stdout, fmt, vl);
3425
}
3426

    
3427
static void show_help(void)
3428
{
3429
    av_log_set_callback(log_callback_help);
3430
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3431
           "Hyper fast Audio and Video encoder\n");
3432
    printf("\n");
3433
    show_help_options(options, "Main options:\n",
3434
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3435
    show_help_options(options, "\nAdvanced options:\n",
3436
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3437
                      OPT_EXPERT);
3438
    show_help_options(options, "\nVideo options:\n",
3439
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3440
                      OPT_VIDEO);
3441
    show_help_options(options, "\nAdvanced Video options:\n",
3442
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3443
                      OPT_VIDEO | OPT_EXPERT);
3444
    show_help_options(options, "\nAudio options:\n",
3445
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3446
                      OPT_AUDIO);
3447
    show_help_options(options, "\nAdvanced Audio options:\n",
3448
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3449
                      OPT_AUDIO | OPT_EXPERT);
3450
    show_help_options(options, "\nSubtitle options:\n",
3451
                      OPT_SUBTITLE | OPT_GRAB,
3452
                      OPT_SUBTITLE);
3453
    show_help_options(options, "\nAudio/Video grab options:\n",
3454
                      OPT_GRAB,
3455
                      OPT_GRAB);
3456
    printf("\n");
3457
    av_opt_show(avctx_opts[0], NULL);
3458
    printf("\n");
3459
    av_opt_show(avformat_opts, NULL);
3460
    printf("\n");
3461
    av_opt_show(sws_opts, NULL);
3462
}
3463

    
3464
static void opt_target(const char *arg)
3465
{
3466
    int norm = -1;
3467
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3468

    
3469
    if(!strncmp(arg, "pal-", 4)) {
3470
        norm = 0;
3471
        arg += 4;
3472
    } else if(!strncmp(arg, "ntsc-", 5)) {
3473
        norm = 1;
3474
        arg += 5;
3475
    } else if(!strncmp(arg, "film-", 5)) {
3476
        norm = 2;
3477
        arg += 5;
3478
    } else {
3479
        int fr;
3480
        /* Calculate FR via float to avoid int overflow */
3481
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3482
        if(fr == 25000) {
3483
            norm = 0;
3484
        } else if((fr == 29970) || (fr == 23976)) {
3485
            norm = 1;
3486
        } else {
3487
            /* Try to determine PAL/NTSC by peeking in the input files */
3488
            if(nb_input_files) {
3489
                int i, j;
3490
                for(j = 0; j < nb_input_files; j++) {
3491
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3492
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3493
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3494
                            continue;
3495
                        fr = c->time_base.den * 1000 / c->time_base.num;
3496
                        if(fr == 25000) {
3497
                            norm = 0;
3498
                            break;
3499
                        } else if((fr == 29970) || (fr == 23976)) {
3500
                            norm = 1;
3501
                            break;
3502
                        }
3503
                    }
3504
                    if(norm >= 0)
3505
                        break;
3506
                }
3507
            }
3508
        }
3509
        if(verbose && norm >= 0)
3510
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3511
    }
3512

    
3513
    if(norm < 0) {
3514
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3515
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3516
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3517
        av_exit(1);
3518
    }
3519

    
3520
    if(!strcmp(arg, "vcd")) {
3521

    
3522
        opt_video_codec("mpeg1video");
3523
        opt_audio_codec("mp2");
3524
        opt_format("vcd");
3525

    
3526
        opt_frame_size(norm ? "352x240" : "352x288");
3527
        opt_frame_rate(frame_rates[norm]);
3528
        opt_default("gop", norm ? "18" : "15");
3529

    
3530
        opt_default("b", "1150000");
3531
        opt_default("maxrate", "1150000");
3532
        opt_default("minrate", "1150000");
3533
        opt_default("bufsize", "327680"); // 40*1024*8;
3534

    
3535
        opt_default("ab", "224000");
3536
        audio_sample_rate = 44100;
3537
        audio_channels = 2;
3538

    
3539
        opt_default("packetsize", "2324");
3540
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3541

    
3542
        /* We have to offset the PTS, so that it is consistent with the SCR.
3543
           SCR starts at 36000, but the first two packs contain only padding
3544
           and the first pack from the other stream, respectively, may also have
3545
           been written before.
3546
           So the real data starts at SCR 36000+3*1200. */
3547
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3548
    } else if(!strcmp(arg, "svcd")) {
3549

    
3550
        opt_video_codec("mpeg2video");
3551
        opt_audio_codec("mp2");
3552
        opt_format("svcd");
3553

    
3554
        opt_frame_size(norm ? "480x480" : "480x576");
3555
        opt_frame_rate(frame_rates[norm]);
3556
        opt_default("gop", norm ? "18" : "15");
3557

    
3558
        opt_default("b", "2040000");
3559
        opt_default("maxrate", "2516000");
3560
        opt_default("minrate", "0"); //1145000;
3561
        opt_default("bufsize", "1835008"); //224*1024*8;
3562
        opt_default("flags", "+SCAN_OFFSET");
3563

    
3564

    
3565
        opt_default("ab", "224000");
3566
        audio_sample_rate = 44100;
3567

    
3568
        opt_default("packetsize", "2324");
3569

    
3570
    } else if(!strcmp(arg, "dvd")) {
3571

    
3572
        opt_video_codec("mpeg2video");
3573
        opt_audio_codec("ac3");
3574
        opt_format("dvd");
3575

    
3576
        opt_frame_size(norm ? "720x480" : "720x576");
3577
        opt_frame_rate(frame_rates[norm]);
3578
        opt_default("gop", norm ? "18" : "15");
3579

    
3580
        opt_default("b", "6000000");
3581
        opt_default("maxrate", "9000000");
3582
        opt_default("minrate", "0"); //1500000;
3583
        opt_default("bufsize", "1835008"); //224*1024*8;
3584

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

    
3588
        opt_default("ab", "448000");
3589
        audio_sample_rate = 48000;
3590

    
3591
    } else if(!strncmp(arg, "dv", 2)) {
3592

    
3593
        opt_format("dv");
3594

    
3595
        opt_frame_size(norm ? "720x480" : "720x576");
3596
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3597
                                             (norm ? "yuv411p" : "yuv420p"));
3598
        opt_frame_rate(frame_rates[norm]);
3599

    
3600
        audio_sample_rate = 48000;
3601
        audio_channels = 2;
3602

    
3603
    } else {
3604
        fprintf(stderr, "Unknown target: %s\n", arg);
3605
        av_exit(1);
3606
    }
3607
}
3608

    
3609
static void opt_vstats_file (const char *arg)
3610
{
3611
    av_free (vstats_filename);
3612
    vstats_filename=av_strdup (arg);
3613
}
3614

    
3615
static void opt_vstats (void)
3616
{
3617
    char filename[40];
3618
    time_t today2 = time(NULL);
3619
    struct tm *today = localtime(&today2);
3620

    
3621
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3622
             today->tm_sec);
3623
    opt_vstats_file(filename);
3624
}
3625

    
3626
static int opt_bsf(const char *opt, const char *arg)
3627
{
3628
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3629
    AVBitStreamFilterContext **bsfp;
3630

    
3631
    if(!bsfc){
3632
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3633
        av_exit(1);
3634
    }
3635

    
3636
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3637
          *opt == 'a' ? &audio_bitstream_filters :
3638
                        &subtitle_bitstream_filters;
3639
    while(*bsfp)
3640
        bsfp= &(*bsfp)->next;
3641

    
3642
    *bsfp= bsfc;
3643

    
3644
    return 0;
3645
}
3646

    
3647
static int opt_preset(const char *opt, const char *arg)
3648
{
3649
    FILE *f=NULL;
3650
    char tmp[1000], tmp2[1000];
3651
    int i;
3652
    const char *base[3]= { getenv("HOME"),
3653
                           "/usr/local/share",
3654
                           "/usr/share",
3655
                         };
3656

    
3657
    for(i=!base[0]; i<3 && !f; i++){
3658
        snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3659
        f= fopen(tmp, "r");
3660
        if(!f){
3661
            char *codec_name= *opt == 'v' ? video_codec_name :
3662
                              *opt == 'a' ? audio_codec_name :
3663
                                            subtitle_codec_name;
3664
              snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3665
            f= fopen(tmp, "r");
3666
        }
3667
    }
3668

    
3669
    if(!f){
3670
        fprintf(stderr, "Preset file not found\n");
3671
        av_exit(1);
3672
    }
3673

    
3674
    while(!feof(f)){
3675
        int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3676
        if(e!=2){
3677
            fprintf(stderr, "Preset file invalid\n");
3678
            av_exit(1);
3679
        }
3680
        if(!strcmp(tmp, "acodec")){
3681
            opt_audio_codec(tmp2);
3682
        }else if(!strcmp(tmp, "vcodec")){
3683
            opt_video_codec(tmp2);
3684
        }else if(!strcmp(tmp, "scodec")){
3685
            opt_subtitle_codec(tmp2);
3686
        }else
3687
            opt_default(tmp, tmp2);
3688
    }
3689

    
3690
    fclose(f);
3691

    
3692
    return 0;
3693
}
3694

    
3695
static const OptionDef options[] = {
3696
    /* main options */
3697
    { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3698
    { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3699
    { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3700
    { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3701
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3702
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3703
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3704
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3705
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3706
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3707
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3708
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3709
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3710
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3711
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3712
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3713
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3714
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3715
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3716
    { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3717
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3718
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3719
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3720
      "add timings for benchmarking" },
3721
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3722
      "dump each input packet" },
3723
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3724
      "when dumping packets, also dump the payload" },
3725
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3726
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3727
    { "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)", "" },
3728
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3729
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3730
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3731
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3732
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3733
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3734
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3735
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3736
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3737
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3738
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3739

    
3740
    /* video options */
3741
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3742
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3743
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3744
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3745
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3746
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3747
    { "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" },
3748
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3749
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3750
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3751
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3752
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3753
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3754
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3755
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3756
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3757
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3758
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3759
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3760
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3761
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3762
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3763
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3764
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3765
      "use same video quality as source (implies VBR)" },
3766
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3767
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3768
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3769
      "deinterlace pictures" },
3770
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3771
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3772
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3773
#ifdef CONFIG_VHOOK
3774
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3775
#endif
3776
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3777
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3778
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3779
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3780
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3781
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3782
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3783

    
3784
    /* audio options */
3785
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3786
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3787
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3788
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3789
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3790
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3791
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3792
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3793
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3794
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3795
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3796

    
3797
    /* subtitle options */
3798
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3799
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3800
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3801
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3802

    
3803
    /* grab options */
3804
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3805
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3806
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3807

    
3808
    /* muxer options */
3809
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3810
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3811

    
3812
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3813
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3814
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3815

    
3816
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3817
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3818
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3819

    
3820
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3821
    { NULL, },
3822
};
3823

    
3824
int main(int argc, char **argv)
3825
{
3826
    int i;
3827
    int64_t ti;
3828

    
3829
    avcodec_register_all();
3830
    avdevice_register_all();
3831
    av_register_all();
3832

    
3833
    if(isatty(STDIN_FILENO))
3834
        url_set_interrupt_cb(decode_interrupt_cb);
3835

    
3836
    for(i=0; i<CODEC_TYPE_NB; i++){
3837
        avctx_opts[i]= avcodec_alloc_context2(i);
3838
    }
3839
    avformat_opts = av_alloc_format_context();
3840
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3841

    
3842
    show_banner();
3843
    if (argc <= 1) {
3844
        show_help();
3845
        av_exit(1);
3846
    }
3847

    
3848
    /* parse options */
3849
    parse_options(argc, argv, options, opt_output_file);
3850

    
3851
    /* file converter / grab */
3852
    if (nb_output_files <= 0) {
3853
        fprintf(stderr, "Must supply at least one output file\n");
3854
        av_exit(1);
3855
    }
3856

    
3857
    if (nb_input_files == 0) {
3858
        fprintf(stderr, "Must supply at least one input file\n");
3859
        av_exit(1);
3860
    }
3861

    
3862
    ti = getutime();
3863
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3864
              stream_maps, nb_stream_maps);
3865
    ti = getutime() - ti;
3866
    if (do_benchmark) {
3867
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3868
    }
3869

    
3870
    return av_exit(0);
3871
}