Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 48291040

History | View | Annotate | Download (136 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 "avformat.h"
31
#include "avdevice.h"
32
#include "swscale.h"
33
#include "framehook.h"
34
#include "opt.h"
35
#include "fifo.h"
36
#include "avstring.h"
37
#include "os_support.h"
38

    
39
#if !defined(HAVE_GETRUSAGE) && defined(HAVE_GETPROCESSTIMES)
40
#include <windows.h>
41
#endif
42

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

    
56
#include "version.h"
57
#include "cmdutils.h"
58

    
59
#undef NDEBUG
60
#include <assert.h>
61

    
62
#if !defined(INFINITY) && defined(HUGE_VAL)
63
#define INFINITY HUGE_VAL
64
#endif
65

    
66
#undef exit
67

    
68
static const char program_name[] = "FFmpeg";
69
static const int program_birth_year = 2000;
70

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

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

    
85
extern const OptionDef options[];
86

    
87
#define MAX_FILES 20
88

    
89
static AVFormatContext *input_files[MAX_FILES];
90
static int64_t input_files_ts_offset[MAX_FILES];
91
static int nb_input_files = 0;
92

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

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

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

    
102
static AVInputFormat *file_iformat;
103
static AVOutputFormat *file_oformat;
104
static int frame_width  = 0;
105
static int frame_height = 0;
106
static float frame_aspect_ratio = 0;
107
static enum PixelFormat frame_pix_fmt = PIX_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 = (AVRational) {0,0};
119
static float video_qscale = 0;
120
static int video_qdiff = 3;
121
static uint16_t *intra_matrix = NULL;
122
static uint16_t *inter_matrix = NULL;
123
#if 0 //experimental, (can be removed)
124
static float video_rc_qsquish=1.0;
125
static float video_rc_qmod_amp=0;
126
static int video_rc_qmod_freq=0;
127
#endif
128
static const char *video_rc_override_string=NULL;
129
static int video_disable = 0;
130
static int video_discard = 0;
131
static char *video_codec_name = NULL;
132
static int video_codec_tag = 0;
133
static int same_quality = 0;
134
static int do_deinterlace = 0;
135
static int strict = 0;
136
static int top_field_first = -1;
137
static int me_threshold = 0;
138
static int intra_dc_precision = 8;
139
static int loop_input = 0;
140
static int loop_output = AVFMT_NOOUTPUTLOOP;
141
static int qp_hist = 0;
142

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

    
153
static int subtitle_disable = 0;
154
static char *subtitle_codec_name = NULL;
155
static char *subtitle_language = NULL;
156

    
157
static float mux_preload= 0.5;
158
static float mux_max_delay= 0.7;
159

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

    
190
static int rate_emu = 0;
191

    
192
static int  video_channel = 0;
193
static char *video_standard;
194

    
195
static int audio_volume = 256;
196

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

    
210
static int pgmyuv_compatibility_hack=0;
211
static float dts_delta_threshold = 10;
212

    
213
static int sws_flags = SWS_BICUBIC;
214

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

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

    
227
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
228

    
229
struct AVInputStream;
230

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

    
249
    int video_crop;
250
    int topBand;             /* cropping area sizes */
251
    int leftBand;
252

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

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

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

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

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

    
289
#ifdef HAVE_TERMIOS_H
290

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

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

    
302
static volatile sig_atomic_t received_sigterm = 0;
303

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

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

    
316
    tcgetattr (0, &tty);
317
    oldtty = tty;
318

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

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

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

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

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

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

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

    
378
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
379
{
380
    int i, err;
381
    AVFormatContext *ic;
382

    
383
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
384
    if (err < 0)
385
        return err;
386
    /* copy stream format */
387
    s->nb_streams = ic->nb_streams;
388
    for(i=0;i<ic->nb_streams;i++) {
389
        AVStream *st;
390

    
391
        // FIXME: a more elegant solution is needed
392
        st = av_mallocz(sizeof(AVStream));
393
        memcpy(st, ic->streams[i], sizeof(AVStream));
394
        st->codec = avcodec_alloc_context();
395
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
396
        s->streams[i] = st;
397
    }
398

    
399
    av_close_input_file(ic);
400
    return 0;
401
}
402

    
403
static double
404
get_sync_ipts(const AVOutputStream *ost)
405
{
406
    const AVInputStream *ist = ost->sync_ist;
407
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
408
}
409

    
410
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
411
    int ret;
412

    
413
    while(bsfc){
414
        AVPacket new_pkt= *pkt;
415
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
416
                                          &new_pkt.data, &new_pkt.size,
417
                                          pkt->data, pkt->size,
418
                                          pkt->flags & PKT_FLAG_KEY);
419
        if(a>0){
420
            av_free_packet(pkt);
421
            new_pkt.destruct= av_destruct_packet;
422
        } else if(a<0){
423
            fprintf(stderr, "%s failed for stream %d, codec %s",
424
                    bsfc->filter->name, pkt->stream_index,
425
                    avctx->codec ? avctx->codec->name : "copy");
426
            print_error("", a);
427
        }
428
        *pkt= new_pkt;
429

    
430
        bsfc= bsfc->next;
431
    }
432

    
433
    ret= av_interleaved_write_frame(s, pkt);
434
    if(ret < 0){
435
        print_error("av_interleaved_write_frame()", ret);
436
        exit(1);
437
    }
438
}
439

    
440
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
441

    
442
static void do_audio_out(AVFormatContext *s,
443
                         AVOutputStream *ost,
444
                         AVInputStream *ist,
445
                         unsigned char *buf, int size)
446
{
447
    uint8_t *buftmp;
448
    static uint8_t *audio_buf = NULL;
449
    static uint8_t *audio_out = NULL;
450
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
451

    
452
    int size_out, frame_bytes, ret;
453
    AVCodecContext *enc= ost->st->codec;
454
    AVCodecContext *dec= ist->st->codec;
455

    
456
    /* SC: dynamic allocation of buffers */
457
    if (!audio_buf)
458
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
459
    if (!audio_out)
460
        audio_out = av_malloc(audio_out_size);
461
    if (!audio_buf || !audio_out)
462
        return;               /* Should signal an error ! */
463

    
464
    if (enc->channels != dec->channels)
465
        ost->audio_resample = 1;
466

    
467
    if (ost->audio_resample && !ost->resample) {
468
        ost->resample = audio_resample_init(enc->channels,    dec->channels,
469
                                            enc->sample_rate, dec->sample_rate);
470
        if (!ost->resample) {
471
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
472
                    dec->channels, dec->sample_rate,
473
                    enc->channels, enc->sample_rate);
474
            exit(1);
475
        }
476
    }
477

    
478
    if(audio_sync_method){
479
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
480
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
481
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
482
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
483

    
484
        //FIXME resample delay
485
        if(fabs(delta) > 50){
486
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
487
                if(byte_delta < 0){
488
                    byte_delta= FFMAX(byte_delta, -size);
489
                    size += byte_delta;
490
                    buf  -= byte_delta;
491
                    if(verbose > 2)
492
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
493
                    if(!size)
494
                        return;
495
                    ist->is_start=0;
496
                }else{
497
                    static uint8_t *input_tmp= NULL;
498
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
499

    
500
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
501
                        ist->is_start=0;
502
                    else
503
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
504

    
505
                    memset(input_tmp, 0, byte_delta);
506
                    memcpy(input_tmp + byte_delta, buf, size);
507
                    buf= input_tmp;
508
                    size += byte_delta;
509
                    if(verbose > 2)
510
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
511
                }
512
            }else if(audio_sync_method>1){
513
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
514
                assert(ost->audio_resample);
515
                if(verbose > 2)
516
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
517
//                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));
518
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
519
            }
520
        }
521
    }else
522
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
523
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
524

    
525
    if (ost->audio_resample) {
526
        buftmp = audio_buf;
527
        size_out = audio_resample(ost->resample,
528
                                  (short *)buftmp, (short *)buf,
529
                                  size / (ist->st->codec->channels * 2));
530
        size_out = size_out * enc->channels * 2;
531
    } else {
532
        buftmp = buf;
533
        size_out = size;
534
    }
535

    
536
    /* now encode as many frames as possible */
537
    if (enc->frame_size > 1) {
538
        /* output resampled raw samples */
539
        av_fifo_write(&ost->fifo, buftmp, size_out);
540

    
541
        frame_bytes = enc->frame_size * 2 * enc->channels;
542

    
543
        while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
544
            AVPacket pkt;
545
            av_init_packet(&pkt);
546

    
547
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
548
                                       (short *)audio_buf);
549
            audio_size += ret;
550
            pkt.stream_index= ost->index;
551
            pkt.data= audio_out;
552
            pkt.size= ret;
553
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
554
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
555
            pkt.flags |= PKT_FLAG_KEY;
556
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
557

    
558
            ost->sync_opts += enc->frame_size;
559
        }
560
    } else {
561
        AVPacket pkt;
562
        av_init_packet(&pkt);
563

    
564
        ost->sync_opts += size_out / (2 * enc->channels);
565

    
566
        /* output a pcm frame */
567
        /* XXX: change encoding codec API to avoid this ? */
568
        switch(enc->codec->id) {
569
        case CODEC_ID_PCM_S32LE:
570
        case CODEC_ID_PCM_S32BE:
571
        case CODEC_ID_PCM_U32LE:
572
        case CODEC_ID_PCM_U32BE:
573
            size_out = size_out << 1;
574
            break;
575
        case CODEC_ID_PCM_S24LE:
576
        case CODEC_ID_PCM_S24BE:
577
        case CODEC_ID_PCM_U24LE:
578
        case CODEC_ID_PCM_U24BE:
579
        case CODEC_ID_PCM_S24DAUD:
580
            size_out = size_out / 2 * 3;
581
            break;
582
        case CODEC_ID_PCM_S16LE:
583
        case CODEC_ID_PCM_S16BE:
584
        case CODEC_ID_PCM_U16LE:
585
        case CODEC_ID_PCM_U16BE:
586
            break;
587
        default:
588
            size_out = size_out >> 1;
589
            break;
590
        }
591
        ret = avcodec_encode_audio(enc, audio_out, size_out,
592
                                   (short *)buftmp);
593
        audio_size += ret;
594
        pkt.stream_index= ost->index;
595
        pkt.data= audio_out;
596
        pkt.size= ret;
597
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
598
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
599
        pkt.flags |= PKT_FLAG_KEY;
600
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
601
    }
602
}
603

    
604
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
605
{
606
    AVCodecContext *dec;
607
    AVPicture *picture2;
608
    AVPicture picture_tmp;
609
    uint8_t *buf = 0;
610

    
611
    dec = ist->st->codec;
612

    
613
    /* deinterlace : must be done before any resize */
614
    if (do_deinterlace || using_vhook) {
615
        int size;
616

    
617
        /* create temporary picture */
618
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
619
        buf = av_malloc(size);
620
        if (!buf)
621
            return;
622

    
623
        picture2 = &picture_tmp;
624
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
625

    
626
        if (do_deinterlace){
627
            if(avpicture_deinterlace(picture2, picture,
628
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
629
                /* if error, do not deinterlace */
630
                av_free(buf);
631
                buf = NULL;
632
                picture2 = picture;
633
            }
634
        } else {
635
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
636
        }
637
    } else {
638
        picture2 = picture;
639
    }
640

    
641
    if (ENABLE_VHOOK)
642
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
643
                           1000000 * ist->pts / AV_TIME_BASE);
644

    
645
    if (picture != picture2)
646
        *picture = *picture2;
647
    *bufp = buf;
648
}
649

    
650
/* we begin to correct av delay at this threshold */
651
#define AV_DELAY_MAX 0.100
652

    
653
static void do_subtitle_out(AVFormatContext *s,
654
                            AVOutputStream *ost,
655
                            AVInputStream *ist,
656
                            AVSubtitle *sub,
657
                            int64_t pts)
658
{
659
    static uint8_t *subtitle_out = NULL;
660
    int subtitle_out_max_size = 65536;
661
    int subtitle_out_size, nb, i;
662
    AVCodecContext *enc;
663
    AVPacket pkt;
664

    
665
    if (pts == AV_NOPTS_VALUE) {
666
        fprintf(stderr, "Subtitle packets must have a pts\n");
667
        return;
668
    }
669

    
670
    enc = ost->st->codec;
671

    
672
    if (!subtitle_out) {
673
        subtitle_out = av_malloc(subtitle_out_max_size);
674
    }
675

    
676
    /* Note: DVB subtitle need one packet to draw them and one other
677
       packet to clear them */
678
    /* XXX: signal it in the codec context ? */
679
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
680
        nb = 2;
681
    else
682
        nb = 1;
683

    
684
    for(i = 0; i < nb; i++) {
685
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
686
                                                    subtitle_out_max_size, sub);
687

    
688
        av_init_packet(&pkt);
689
        pkt.stream_index = ost->index;
690
        pkt.data = subtitle_out;
691
        pkt.size = subtitle_out_size;
692
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
693
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
694
            /* XXX: the pts correction is handled here. Maybe handling
695
               it in the codec would be better */
696
            if (i == 0)
697
                pkt.pts += 90 * sub->start_display_time;
698
            else
699
                pkt.pts += 90 * sub->end_display_time;
700
        }
701
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
702
    }
703
}
704

    
705
static int bit_buffer_size= 1024*256;
706
static uint8_t *bit_buffer= NULL;
707

    
708
static void do_video_out(AVFormatContext *s,
709
                         AVOutputStream *ost,
710
                         AVInputStream *ist,
711
                         AVFrame *in_picture,
712
                         int *frame_size)
713
{
714
    int nb_frames, i, ret;
715
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
716
    AVFrame picture_crop_temp, picture_pad_temp;
717
    AVCodecContext *enc, *dec;
718

    
719
    avcodec_get_frame_defaults(&picture_crop_temp);
720
    avcodec_get_frame_defaults(&picture_pad_temp);
721

    
722
    enc = ost->st->codec;
723
    dec = ist->st->codec;
724

    
725
    /* by default, we output a single frame */
726
    nb_frames = 1;
727

    
728
    *frame_size = 0;
729

    
730
    if(video_sync_method){
731
        double vdelta;
732
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
733
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
734
        if (vdelta < -1.1)
735
            nb_frames = 0;
736
        else if (video_sync_method == 2)
737
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
738
        else if (vdelta > 1.1)
739
            nb_frames = lrintf(vdelta);
740
//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);
741
        if (nb_frames == 0){
742
            ++nb_frames_drop;
743
            if (verbose>2)
744
                fprintf(stderr, "*** drop!\n");
745
        }else if (nb_frames > 1) {
746
            nb_frames_dup += nb_frames;
747
            if (verbose>2)
748
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
749
        }
750
    }else
751
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
752

    
753
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
754
    if (nb_frames <= 0)
755
        return;
756

    
757
    if (ost->video_crop) {
758
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
759
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
760
            return;
761
        }
762
        formatted_picture = &picture_crop_temp;
763
    } else {
764
        formatted_picture = in_picture;
765
    }
766

    
767
    final_picture = formatted_picture;
768
    padding_src = formatted_picture;
769
    resampling_dst = &ost->pict_tmp;
770
    if (ost->video_pad) {
771
        final_picture = &ost->pict_tmp;
772
        if (ost->video_resample) {
773
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
774
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
775
                return;
776
            }
777
            resampling_dst = &picture_pad_temp;
778
        }
779
    }
780

    
781
    if (ost->video_resample) {
782
        padding_src = NULL;
783
        final_picture = &ost->pict_tmp;
784
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
785
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
786
    }
787

    
788
    if (ost->video_pad) {
789
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
790
                enc->height, enc->width, enc->pix_fmt,
791
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
792
    }
793

    
794
    /* duplicates frame if needed */
795
    for(i=0;i<nb_frames;i++) {
796
        AVPacket pkt;
797
        av_init_packet(&pkt);
798
        pkt.stream_index= ost->index;
799

    
800
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
801
            /* raw pictures are written as AVPicture structure to
802
               avoid any copies. We support temorarily the older
803
               method. */
804
            AVFrame* old_frame = enc->coded_frame;
805
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
806
            pkt.data= (uint8_t *)final_picture;
807
            pkt.size=  sizeof(AVPicture);
808
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
809
            pkt.flags |= PKT_FLAG_KEY;
810

    
811
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
812
            enc->coded_frame = old_frame;
813
        } else {
814
            AVFrame big_picture;
815

    
816
            big_picture= *final_picture;
817
            /* better than nothing: use input picture interlaced
818
               settings */
819
            big_picture.interlaced_frame = in_picture->interlaced_frame;
820
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
821
                if(top_field_first == -1)
822
                    big_picture.top_field_first = in_picture->top_field_first;
823
                else
824
                    big_picture.top_field_first = top_field_first;
825
            }
826

    
827
            /* handles sameq here. This is not correct because it may
828
               not be a global option */
829
            if (same_quality) {
830
                big_picture.quality = ist->st->quality;
831
            }else
832
                big_picture.quality = ost->st->quality;
833
            if(!me_threshold)
834
                big_picture.pict_type = 0;
835
//            big_picture.pts = AV_NOPTS_VALUE;
836
            big_picture.pts= ost->sync_opts;
837
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
838
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
839
            ret = avcodec_encode_video(enc,
840
                                       bit_buffer, bit_buffer_size,
841
                                       &big_picture);
842
            if (ret == -1) {
843
                fprintf(stderr, "Video encoding failed\n");
844
                exit(1);
845
            }
846
            //enc->frame_number = enc->real_pict_num;
847
            if(ret>0){
848
                pkt.data= bit_buffer;
849
                pkt.size= ret;
850
                if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
851
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
852
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
853
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
854
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
855

    
856
                if(enc->coded_frame && enc->coded_frame->key_frame)
857
                    pkt.flags |= PKT_FLAG_KEY;
858
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
859
                *frame_size = ret;
860
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
861
                //        enc->frame_number-1, enc->real_pict_num, ret,
862
                //        enc->pict_type);
863
                /* if two pass, output log */
864
                if (ost->logfile && enc->stats_out) {
865
                    fprintf(ost->logfile, "%s", enc->stats_out);
866
                }
867
            }
868
        }
869
        ost->sync_opts++;
870
        ost->frame_number++;
871
    }
872
}
873

    
874
static double psnr(double d){
875
    if(d==0) return INFINITY;
876
    return -10.0*log(d)/log(10.0);
877
}
878

    
879
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
880
                           int frame_size)
881
{
882
    AVCodecContext *enc;
883
    int frame_number;
884
    double ti1, bitrate, avg_bitrate;
885

    
886
    /* this is executed just the first time do_video_stats is called */
887
    if (!vstats_file) {
888
        vstats_file = fopen(vstats_filename, "w");
889
        if (!vstats_file) {
890
            perror("fopen");
891
            exit(1);
892
        }
893
    }
894

    
895
    enc = ost->st->codec;
896
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
897
        frame_number = ost->frame_number;
898
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
899
        if (enc->flags&CODEC_FLAG_PSNR)
900
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
901

    
902
        fprintf(vstats_file,"f_size= %6d ", frame_size);
903
        /* compute pts value */
904
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
905
        if (ti1 < 0.01)
906
            ti1 = 0.01;
907

    
908
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
909
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
910
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
911
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
912
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
913
    }
914
}
915

    
916
static void print_report(AVFormatContext **output_files,
917
                         AVOutputStream **ost_table, int nb_ostreams,
918
                         int is_last_report)
919
{
920
    char buf[1024];
921
    AVOutputStream *ost;
922
    AVFormatContext *oc, *os;
923
    int64_t total_size;
924
    AVCodecContext *enc;
925
    int frame_number, vid, i;
926
    double bitrate, ti1, pts;
927
    static int64_t last_time = -1;
928
    static int qp_histogram[52];
929

    
930
    if (!is_last_report) {
931
        int64_t cur_time;
932
        /* display the report every 0.5 seconds */
933
        cur_time = av_gettime();
934
        if (last_time == -1) {
935
            last_time = cur_time;
936
            return;
937
        }
938
        if ((cur_time - last_time) < 500000)
939
            return;
940
        last_time = cur_time;
941
    }
942

    
943

    
944
    oc = output_files[0];
945

    
946
    total_size = url_fsize(oc->pb);
947
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
948
        total_size= url_ftell(oc->pb);
949

    
950
    buf[0] = '\0';
951
    ti1 = 1e10;
952
    vid = 0;
953
    for(i=0;i<nb_ostreams;i++) {
954
        ost = ost_table[i];
955
        os = output_files[ost->file_index];
956
        enc = ost->st->codec;
957
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
958
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
959
                     enc->coded_frame && !ost->st->stream_copy ?
960
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
961
        }
962
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
963
            float t = (av_gettime()-timer_start) / 1000000.0;
964

    
965
            frame_number = ost->frame_number;
966
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
967
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
968
                     enc->coded_frame && !ost->st->stream_copy ?
969
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
970
            if(is_last_report)
971
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
972
            if(qp_hist && enc->coded_frame){
973
                int j;
974
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
975
                if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
976
                    qp_histogram[qp]++;
977
                for(j=0; j<32; j++)
978
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
979
            }
980
            if (enc->flags&CODEC_FLAG_PSNR){
981
                int j;
982
                double error, error_sum=0;
983
                double scale, scale_sum=0;
984
                char type[3]= {'Y','U','V'};
985
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
986
                for(j=0; j<3; j++){
987
                    if(is_last_report){
988
                        error= enc->error[j];
989
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
990
                    }else{
991
                        error= enc->coded_frame->error[j];
992
                        scale= enc->width*enc->height*255.0*255.0;
993
                    }
994
                    if(j) scale/=4;
995
                    error_sum += error;
996
                    scale_sum += scale;
997
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
998
                }
999
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1000
            }
1001
            vid = 1;
1002
        }
1003
        /* compute min output value */
1004
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1005
        if ((pts < ti1) && (pts > 0))
1006
            ti1 = pts;
1007
    }
1008
    if (ti1 < 0.01)
1009
        ti1 = 0.01;
1010

    
1011
    if (verbose || is_last_report) {
1012
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1013

    
1014
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1015
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1016
            (double)total_size / 1024, ti1, bitrate);
1017

    
1018
        if (verbose > 1)
1019
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1020
                  nb_frames_dup, nb_frames_drop);
1021

    
1022
        if (verbose >= 0)
1023
            fprintf(stderr, "%s    \r", buf);
1024

    
1025
        fflush(stderr);
1026
    }
1027

    
1028
    if (is_last_report && verbose >= 0){
1029
        int64_t raw= audio_size + video_size + extra_size;
1030
        fprintf(stderr, "\n");
1031
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1032
                video_size/1024.0,
1033
                audio_size/1024.0,
1034
                extra_size/1024.0,
1035
                100.0*(total_size - raw)/raw
1036
        );
1037
    }
1038
}
1039

    
1040
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1041
static int output_packet(AVInputStream *ist, int ist_index,
1042
                         AVOutputStream **ost_table, int nb_ostreams,
1043
                         const AVPacket *pkt)
1044
{
1045
    AVFormatContext *os;
1046
    AVOutputStream *ost;
1047
    uint8_t *ptr;
1048
    int len, ret, i;
1049
    uint8_t *data_buf;
1050
    int data_size, got_picture;
1051
    AVFrame picture;
1052
    void *buffer_to_free;
1053
    static unsigned int samples_size= 0;
1054
    static short *samples= NULL;
1055
    AVSubtitle subtitle, *subtitle_to_free;
1056
    int got_subtitle;
1057

    
1058
    if(ist->next_pts == AV_NOPTS_VALUE)
1059
        ist->next_pts= ist->pts;
1060

    
1061
    if (pkt == NULL) {
1062
        /* EOF handling */
1063
        ptr = NULL;
1064
        len = 0;
1065
        goto handle_eof;
1066
    }
1067

    
1068
    if(pkt->dts != AV_NOPTS_VALUE)
1069
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1070

    
1071
    len = pkt->size;
1072
    ptr = pkt->data;
1073
    while (len > 0) {
1074
    handle_eof:
1075
        ist->pts= ist->next_pts;
1076

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

    
1080
        /* decode the packet if needed */
1081
        data_buf = NULL; /* fail safe */
1082
        data_size = 0;
1083
        subtitle_to_free = NULL;
1084
        if (ist->decoding_needed) {
1085
            switch(ist->st->codec->codec_type) {
1086
            case CODEC_TYPE_AUDIO:{
1087
                if(pkt)
1088
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1089
                data_size= samples_size;
1090
                    /* XXX: could avoid copy if PCM 16 bits with same
1091
                       endianness as CPU */
1092
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1093
                                           ptr, len);
1094
                if (ret < 0)
1095
                    goto fail_decode;
1096
                ptr += ret;
1097
                len -= ret;
1098
                /* Some bug in mpeg audio decoder gives */
1099
                /* data_size < 0, it seems they are overflows */
1100
                if (data_size <= 0) {
1101
                    /* no audio frame */
1102
                    continue;
1103
                }
1104
                data_buf = (uint8_t *)samples;
1105
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1106
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1107
                break;}
1108
            case CODEC_TYPE_VIDEO:
1109
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1110
                    /* XXX: allocate picture correctly */
1111
                    avcodec_get_frame_defaults(&picture);
1112

    
1113
                    ret = avcodec_decode_video(ist->st->codec,
1114
                                               &picture, &got_picture, ptr, len);
1115
                    ist->st->quality= picture.quality;
1116
                    if (ret < 0)
1117
                        goto fail_decode;
1118
                    if (!got_picture) {
1119
                        /* no picture yet */
1120
                        goto discard_packet;
1121
                    }
1122
                    if (ist->st->codec->time_base.num != 0) {
1123
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1124
                                          ist->st->codec->time_base.num) /
1125
                            ist->st->codec->time_base.den;
1126
                    }
1127
                    len = 0;
1128
                    break;
1129
            case CODEC_TYPE_SUBTITLE:
1130
                ret = avcodec_decode_subtitle(ist->st->codec,
1131
                                              &subtitle, &got_subtitle, ptr, len);
1132
                if (ret < 0)
1133
                    goto fail_decode;
1134
                if (!got_subtitle) {
1135
                    goto discard_packet;
1136
                }
1137
                subtitle_to_free = &subtitle;
1138
                len = 0;
1139
                break;
1140
            default:
1141
                goto fail_decode;
1142
            }
1143
        } else {
1144
            switch(ist->st->codec->codec_type) {
1145
            case CODEC_TYPE_AUDIO:
1146
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1147
                    ist->st->codec->sample_rate;
1148
                break;
1149
            case CODEC_TYPE_VIDEO:
1150
                if (ist->st->codec->time_base.num != 0) {
1151
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1152
                                      ist->st->codec->time_base.num) /
1153
                        ist->st->codec->time_base.den;
1154
                }
1155
                break;
1156
            }
1157
            data_buf = ptr;
1158
            data_size = len;
1159
            ret = len;
1160
            len = 0;
1161
        }
1162

    
1163
        buffer_to_free = NULL;
1164
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1165
            pre_process_video_frame(ist, (AVPicture *)&picture,
1166
                                    &buffer_to_free);
1167
        }
1168

    
1169
        // preprocess audio (volume)
1170
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1171
            if (audio_volume != 256) {
1172
                short *volp;
1173
                volp = samples;
1174
                for(i=0;i<(data_size / sizeof(short));i++) {
1175
                    int v = ((*volp) * audio_volume + 128) >> 8;
1176
                    if (v < -32768) v = -32768;
1177
                    if (v >  32767) v = 32767;
1178
                    *volp++ = v;
1179
                }
1180
            }
1181
        }
1182

    
1183
        /* frame rate emulation */
1184
        if (ist->st->codec->rate_emu) {
1185
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1186
            int64_t now = av_gettime() - ist->start;
1187
            if (pts > now)
1188
                usleep(pts - now);
1189

    
1190
            ist->frame++;
1191
        }
1192

    
1193
#if 0
1194
        /* mpeg PTS deordering : if it is a P or I frame, the PTS
1195
           is the one of the next displayed one */
1196
        /* XXX: add mpeg4 too ? */
1197
        if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1198
            if (ist->st->codec->pict_type != B_TYPE) {
1199
                int64_t tmp;
1200
                tmp = ist->last_ip_pts;
1201
                ist->last_ip_pts  = ist->frac_pts.val;
1202
                ist->frac_pts.val = tmp;
1203
            }
1204
        }
1205
#endif
1206
        /* if output time reached then transcode raw format,
1207
           encode packets and output them */
1208
        if (start_time == 0 || ist->pts >= start_time)
1209
            for(i=0;i<nb_ostreams;i++) {
1210
                int frame_size;
1211

    
1212
                ost = ost_table[i];
1213
                if (ost->source_index == ist_index) {
1214
                    os = output_files[ost->file_index];
1215

    
1216
#if 0
1217
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1218
                           (double)pkt->pts / AV_TIME_BASE,
1219
                           ((double)ist->pts / AV_TIME_BASE) -
1220
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1221
#endif
1222
                    /* set the input output pts pairs */
1223
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1224

    
1225
                    if (ost->encoding_needed) {
1226
                        switch(ost->st->codec->codec_type) {
1227
                        case CODEC_TYPE_AUDIO:
1228
                            do_audio_out(os, ost, ist, data_buf, data_size);
1229
                            break;
1230
                        case CODEC_TYPE_VIDEO:
1231
                            do_video_out(os, ost, ist, &picture, &frame_size);
1232
                            video_size += frame_size;
1233
                            if (vstats_filename && frame_size)
1234
                                do_video_stats(os, ost, frame_size);
1235
                            break;
1236
                        case CODEC_TYPE_SUBTITLE:
1237
                            do_subtitle_out(os, ost, ist, &subtitle,
1238
                                            pkt->pts);
1239
                            break;
1240
                        default:
1241
                            abort();
1242
                        }
1243
                    } else {
1244
                        AVFrame avframe; //FIXME/XXX remove this
1245
                        AVPacket opkt;
1246
                        av_init_packet(&opkt);
1247

    
1248
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1249
                            continue;
1250

    
1251
                        /* no reencoding needed : output the packet directly */
1252
                        /* force the input stream PTS */
1253

    
1254
                        avcodec_get_frame_defaults(&avframe);
1255
                        ost->st->codec->coded_frame= &avframe;
1256
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1257

    
1258
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1259
                            audio_size += data_size;
1260
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1261
                            video_size += data_size;
1262
                            ost->sync_opts++;
1263
                        }
1264

    
1265
                        opkt.stream_index= ost->index;
1266
                        if(pkt->pts != AV_NOPTS_VALUE)
1267
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1268
                        else
1269
                            opkt.pts= AV_NOPTS_VALUE;
1270

    
1271
                            if (pkt->dts == AV_NOPTS_VALUE)
1272
                                opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1273
                            else
1274
                                opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1275

    
1276
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1277
                        opkt.flags= pkt->flags;
1278

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

    
1283
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1284
                        ost->st->codec->frame_number++;
1285
                        ost->frame_number++;
1286
                        av_free_packet(&opkt);
1287
                    }
1288
                }
1289
            }
1290
        av_free(buffer_to_free);
1291
        /* XXX: allocate the subtitles in the codec ? */
1292
        if (subtitle_to_free) {
1293
            if (subtitle_to_free->rects != NULL) {
1294
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1295
                    av_free(subtitle_to_free->rects[i].bitmap);
1296
                    av_free(subtitle_to_free->rects[i].rgba_palette);
1297
                }
1298
                av_freep(&subtitle_to_free->rects);
1299
            }
1300
            subtitle_to_free->num_rects = 0;
1301
            subtitle_to_free = NULL;
1302
        }
1303
    }
1304
 discard_packet:
1305
    if (pkt == NULL) {
1306
        /* EOF handling */
1307

    
1308
        for(i=0;i<nb_ostreams;i++) {
1309
            ost = ost_table[i];
1310
            if (ost->source_index == ist_index) {
1311
                AVCodecContext *enc= ost->st->codec;
1312
                os = output_files[ost->file_index];
1313

    
1314
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1315
                    continue;
1316
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1317
                    continue;
1318

    
1319
                if (ost->encoding_needed) {
1320
                    for(;;) {
1321
                        AVPacket pkt;
1322
                        int fifo_bytes;
1323
                        av_init_packet(&pkt);
1324
                        pkt.stream_index= ost->index;
1325

    
1326
                        switch(ost->st->codec->codec_type) {
1327
                        case CODEC_TYPE_AUDIO:
1328
                            fifo_bytes = av_fifo_size(&ost->fifo);
1329
                            ret = 0;
1330
                            /* encode any samples remaining in fifo */
1331
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1332
                                int fs_tmp = enc->frame_size;
1333
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1334
                                if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1335
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1336
                                }
1337
                                enc->frame_size = fs_tmp;
1338
                            }
1339
                            if(ret <= 0) {
1340
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1341
                            }
1342
                            audio_size += ret;
1343
                            pkt.flags |= PKT_FLAG_KEY;
1344
                            break;
1345
                        case CODEC_TYPE_VIDEO:
1346
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1347
                            video_size += ret;
1348
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1349
                                pkt.flags |= PKT_FLAG_KEY;
1350
                            if (ost->logfile && enc->stats_out) {
1351
                                fprintf(ost->logfile, "%s", enc->stats_out);
1352
                            }
1353
                            break;
1354
                        default:
1355
                            ret=-1;
1356
                        }
1357

    
1358
                        if(ret<=0)
1359
                            break;
1360
                        pkt.data= bit_buffer;
1361
                        pkt.size= ret;
1362
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1363
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1364
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1365
                    }
1366
                }
1367
            }
1368
        }
1369
    }
1370

    
1371
    return 0;
1372
 fail_decode:
1373
    return -1;
1374
}
1375

    
1376
static void print_sdp(AVFormatContext **avc, int n)
1377
{
1378
    char sdp[2048];
1379

    
1380
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1381
    printf("SDP:\n%s\n", sdp);
1382
}
1383

    
1384
static int stream_index_from_inputs(AVFormatContext **input_files,
1385
                                    int nb_input_files,
1386
                                    AVInputFile *file_table,
1387
                                    AVInputStream **ist_table,
1388
                                    enum CodecType type,
1389
                                    int programid)
1390
{
1391
    int p, q, z;
1392
    for(z=0; z<nb_input_files; z++) {
1393
        AVFormatContext *ic = input_files[z];
1394
        for(p=0; p<ic->nb_programs; p++) {
1395
            AVProgram *program = ic->programs[p];
1396
            if(program->id != programid)
1397
                continue;
1398
            for(q=0; q<program->nb_stream_indexes; q++) {
1399
                int sidx = program->stream_index[q];
1400
                int ris = file_table[z].ist_index + sidx;
1401
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1402
                    return ris;
1403
            }
1404
        }
1405
    }
1406

    
1407
    return -1;
1408
}
1409

    
1410
/*
1411
 * The following code is the main loop of the file converter
1412
 */
1413
static int av_encode(AVFormatContext **output_files,
1414
                     int nb_output_files,
1415
                     AVFormatContext **input_files,
1416
                     int nb_input_files,
1417
                     AVStreamMap *stream_maps, int nb_stream_maps)
1418
{
1419
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1420
    AVFormatContext *is, *os;
1421
    AVCodecContext *codec, *icodec;
1422
    AVOutputStream *ost, **ost_table = NULL;
1423
    AVInputStream *ist, **ist_table = NULL;
1424
    AVInputFile *file_table;
1425
    int key;
1426
    int want_sdp = 1;
1427

    
1428
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1429
    if (!file_table)
1430
        goto fail;
1431

    
1432
    /* input stream init */
1433
    j = 0;
1434
    for(i=0;i<nb_input_files;i++) {
1435
        is = input_files[i];
1436
        file_table[i].ist_index = j;
1437
        file_table[i].nb_streams = is->nb_streams;
1438
        j += is->nb_streams;
1439
    }
1440
    nb_istreams = j;
1441

    
1442
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1443
    if (!ist_table)
1444
        goto fail;
1445

    
1446
    for(i=0;i<nb_istreams;i++) {
1447
        ist = av_mallocz(sizeof(AVInputStream));
1448
        if (!ist)
1449
            goto fail;
1450
        ist_table[i] = ist;
1451
    }
1452
    j = 0;
1453
    for(i=0;i<nb_input_files;i++) {
1454
        is = input_files[i];
1455
        for(k=0;k<is->nb_streams;k++) {
1456
            ist = ist_table[j++];
1457
            ist->st = is->streams[k];
1458
            ist->file_index = i;
1459
            ist->index = k;
1460
            ist->discard = 1; /* the stream is discarded by default
1461
                                 (changed later) */
1462

    
1463
            if (ist->st->codec->rate_emu) {
1464
                ist->start = av_gettime();
1465
                ist->frame = 0;
1466
            }
1467
        }
1468
    }
1469

    
1470
    /* output stream init */
1471
    nb_ostreams = 0;
1472
    for(i=0;i<nb_output_files;i++) {
1473
        os = output_files[i];
1474
        if (!os->nb_streams) {
1475
            fprintf(stderr, "Output file does not contain any stream\n");
1476
            exit(1);
1477
        }
1478
        nb_ostreams += os->nb_streams;
1479
    }
1480
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1481
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1482
        exit(1);
1483
    }
1484

    
1485
    /* Sanity check the mapping args -- do the input files & streams exist? */
1486
    for(i=0;i<nb_stream_maps;i++) {
1487
        int fi = stream_maps[i].file_index;
1488
        int si = stream_maps[i].stream_index;
1489

    
1490
        if (fi < 0 || fi > nb_input_files - 1 ||
1491
            si < 0 || si > file_table[fi].nb_streams - 1) {
1492
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1493
            exit(1);
1494
        }
1495
        fi = stream_maps[i].sync_file_index;
1496
        si = stream_maps[i].sync_stream_index;
1497
        if (fi < 0 || fi > nb_input_files - 1 ||
1498
            si < 0 || si > file_table[fi].nb_streams - 1) {
1499
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1500
            exit(1);
1501
        }
1502
    }
1503

    
1504
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1505
    if (!ost_table)
1506
        goto fail;
1507
    for(i=0;i<nb_ostreams;i++) {
1508
        ost = av_mallocz(sizeof(AVOutputStream));
1509
        if (!ost)
1510
            goto fail;
1511
        ost_table[i] = ost;
1512
    }
1513

    
1514
    n = 0;
1515
    for(k=0;k<nb_output_files;k++) {
1516
        os = output_files[k];
1517
        for(i=0;i<os->nb_streams;i++) {
1518
            int found;
1519
            ost = ost_table[n++];
1520
            ost->file_index = k;
1521
            ost->index = i;
1522
            ost->st = os->streams[i];
1523
            if (nb_stream_maps > 0) {
1524
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1525
                    stream_maps[n-1].stream_index;
1526

    
1527
                /* Sanity check that the stream types match */
1528
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1529
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1530
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1531
                        ost->file_index, ost->index);
1532
                    exit(1);
1533
                }
1534

    
1535
            } else {
1536
                if(opt_programid) {
1537
                    found = 0;
1538
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1539
                    if(j != -1) {
1540
                        ost->source_index = j;
1541
                        found = 1;
1542
                    }
1543
                } else {
1544
                    /* get corresponding input stream index : we select the first one with the right type */
1545
                    found = 0;
1546
                    for(j=0;j<nb_istreams;j++) {
1547
                        ist = ist_table[j];
1548
                        if (ist->discard &&
1549
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1550
                            ost->source_index = j;
1551
                            found = 1;
1552
                            break;
1553
                        }
1554
                    }
1555
                }
1556

    
1557
                if (!found) {
1558
                    if(! opt_programid) {
1559
                        /* try again and reuse existing stream */
1560
                        for(j=0;j<nb_istreams;j++) {
1561
                            ist = ist_table[j];
1562
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1563
                                ost->source_index = j;
1564
                                found = 1;
1565
                            }
1566
                        }
1567
                    }
1568
                    if (!found) {
1569
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1570
                                ost->file_index, ost->index);
1571
                        exit(1);
1572
                    }
1573
                }
1574
            }
1575
            ist = ist_table[ost->source_index];
1576
            ist->discard = 0;
1577
            ost->sync_ist = (nb_stream_maps > 0) ?
1578
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1579
                         stream_maps[n-1].sync_stream_index] : ist;
1580
        }
1581
    }
1582

    
1583
    /* for each output stream, we compute the right encoding parameters */
1584
    for(i=0;i<nb_ostreams;i++) {
1585
        ost = ost_table[i];
1586
        os = output_files[ost->file_index];
1587
        ist = ist_table[ost->source_index];
1588

    
1589
        codec = ost->st->codec;
1590
        icodec = ist->st->codec;
1591

    
1592
        if (!ost->st->language[0])
1593
            av_strlcpy(ost->st->language, ist->st->language,
1594
                       sizeof(ost->st->language));
1595

    
1596
        if (ost->st->stream_copy) {
1597
            /* if stream_copy is selected, no need to decode or encode */
1598
            codec->codec_id = icodec->codec_id;
1599
            codec->codec_type = icodec->codec_type;
1600

    
1601
            if(!codec->codec_tag){
1602
                if(   !os->oformat->codec_tag
1603
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1604
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1605
                    codec->codec_tag = icodec->codec_tag;
1606
            }
1607

    
1608
            codec->bit_rate = icodec->bit_rate;
1609
            codec->extradata= icodec->extradata;
1610
            codec->extradata_size= icodec->extradata_size;
1611
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1612
                codec->time_base = icodec->time_base;
1613
            else
1614
                codec->time_base = ist->st->time_base;
1615
            switch(codec->codec_type) {
1616
            case CODEC_TYPE_AUDIO:
1617
                codec->sample_rate = icodec->sample_rate;
1618
                codec->channels = icodec->channels;
1619
                codec->frame_size = icodec->frame_size;
1620
                codec->block_align= icodec->block_align;
1621
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1622
                    codec->block_align= 0;
1623
                break;
1624
            case CODEC_TYPE_VIDEO:
1625
                if(using_vhook) {
1626
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1627
                    exit(1);
1628
                }
1629
                codec->pix_fmt = icodec->pix_fmt;
1630
                codec->width = icodec->width;
1631
                codec->height = icodec->height;
1632
                codec->has_b_frames = icodec->has_b_frames;
1633
                break;
1634
            case CODEC_TYPE_SUBTITLE:
1635
                break;
1636
            default:
1637
                abort();
1638
            }
1639
        } else {
1640
            switch(codec->codec_type) {
1641
            case CODEC_TYPE_AUDIO:
1642
                if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1643
                    goto fail;
1644
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1645
                icodec->request_channels = codec->channels;
1646
                ist->decoding_needed = 1;
1647
                ost->encoding_needed = 1;
1648
                break;
1649
            case CODEC_TYPE_VIDEO:
1650
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1651
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1652
                ost->video_resample = ((codec->width != icodec->width -
1653
                                (frame_leftBand + frame_rightBand) +
1654
                                (frame_padleft + frame_padright)) ||
1655
                        (codec->height != icodec->height -
1656
                                (frame_topBand  + frame_bottomBand) +
1657
                                (frame_padtop + frame_padbottom)) ||
1658
                        (codec->pix_fmt != icodec->pix_fmt));
1659
                if (ost->video_crop) {
1660
                    ost->topBand = frame_topBand;
1661
                    ost->leftBand = frame_leftBand;
1662
                }
1663
                if (ost->video_pad) {
1664
                    ost->padtop = frame_padtop;
1665
                    ost->padleft = frame_padleft;
1666
                    ost->padbottom = frame_padbottom;
1667
                    ost->padright = frame_padright;
1668
                    if (!ost->video_resample) {
1669
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1670
                        if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1671
                                         codec->width, codec->height ) )
1672
                            goto fail;
1673
                    }
1674
                }
1675
                if (ost->video_resample) {
1676
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1677
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1678
                                         codec->width, codec->height ) ) {
1679
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1680
                        exit(1);
1681
                    }
1682
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1683
                    ost->img_resample_ctx = sws_getContext(
1684
                            icodec->width - (frame_leftBand + frame_rightBand),
1685
                            icodec->height - (frame_topBand + frame_bottomBand),
1686
                            icodec->pix_fmt,
1687
                            codec->width - (frame_padleft + frame_padright),
1688
                            codec->height - (frame_padtop + frame_padbottom),
1689
                            codec->pix_fmt,
1690
                            sws_flags, NULL, NULL, NULL);
1691
                    if (ost->img_resample_ctx == NULL) {
1692
                        fprintf(stderr, "Cannot get resampling context\n");
1693
                        exit(1);
1694
                    }
1695
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1696
                }
1697
                ost->encoding_needed = 1;
1698
                ist->decoding_needed = 1;
1699
                break;
1700
            case CODEC_TYPE_SUBTITLE:
1701
                ost->encoding_needed = 1;
1702
                ist->decoding_needed = 1;
1703
                break;
1704
            default:
1705
                abort();
1706
                break;
1707
            }
1708
            /* two pass mode */
1709
            if (ost->encoding_needed &&
1710
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1711
                char logfilename[1024];
1712
                FILE *f;
1713
                int size;
1714
                char *logbuffer;
1715

    
1716
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1717
                         pass_logfilename ?
1718
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1719
                if (codec->flags & CODEC_FLAG_PASS1) {
1720
                    f = fopen(logfilename, "w");
1721
                    if (!f) {
1722
                        perror(logfilename);
1723
                        exit(1);
1724
                    }
1725
                    ost->logfile = f;
1726
                } else {
1727
                    /* read the log file */
1728
                    f = fopen(logfilename, "r");
1729
                    if (!f) {
1730
                        perror(logfilename);
1731
                        exit(1);
1732
                    }
1733
                    fseek(f, 0, SEEK_END);
1734
                    size = ftell(f);
1735
                    fseek(f, 0, SEEK_SET);
1736
                    logbuffer = av_malloc(size + 1);
1737
                    if (!logbuffer) {
1738
                        fprintf(stderr, "Could not allocate log buffer\n");
1739
                        exit(1);
1740
                    }
1741
                    size = fread(logbuffer, 1, size, f);
1742
                    fclose(f);
1743
                    logbuffer[size] = '\0';
1744
                    codec->stats_in = logbuffer;
1745
                }
1746
            }
1747
        }
1748
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1749
            int size= codec->width * codec->height;
1750
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1751
        }
1752
    }
1753

    
1754
    if (!bit_buffer)
1755
        bit_buffer = av_malloc(bit_buffer_size);
1756
    if (!bit_buffer)
1757
        goto fail;
1758

    
1759
    /* dump the file output parameters - cannot be done before in case
1760
       of stream copy */
1761
    for(i=0;i<nb_output_files;i++) {
1762
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1763
    }
1764

    
1765
    /* dump the stream mapping */
1766
    if (verbose >= 0) {
1767
        fprintf(stderr, "Stream mapping:\n");
1768
        for(i=0;i<nb_ostreams;i++) {
1769
            ost = ost_table[i];
1770
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1771
                    ist_table[ost->source_index]->file_index,
1772
                    ist_table[ost->source_index]->index,
1773
                    ost->file_index,
1774
                    ost->index);
1775
            if (ost->sync_ist != ist_table[ost->source_index])
1776
                fprintf(stderr, " [sync #%d.%d]",
1777
                        ost->sync_ist->file_index,
1778
                        ost->sync_ist->index);
1779
            fprintf(stderr, "\n");
1780
        }
1781
    }
1782

    
1783
    /* open each encoder */
1784
    for(i=0;i<nb_ostreams;i++) {
1785
        ost = ost_table[i];
1786
        if (ost->encoding_needed) {
1787
            AVCodec *codec;
1788
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1789
            if (!codec) {
1790
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1791
                        ost->file_index, ost->index);
1792
                exit(1);
1793
            }
1794
            if (avcodec_open(ost->st->codec, codec) < 0) {
1795
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1796
                        ost->file_index, ost->index);
1797
                exit(1);
1798
            }
1799
            extra_size += ost->st->codec->extradata_size;
1800
        }
1801
    }
1802

    
1803
    /* open each decoder */
1804
    for(i=0;i<nb_istreams;i++) {
1805
        ist = ist_table[i];
1806
        if (ist->decoding_needed) {
1807
            AVCodec *codec;
1808
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1809
            if (!codec) {
1810
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1811
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1812
                exit(1);
1813
            }
1814
            if (avcodec_open(ist->st->codec, codec) < 0) {
1815
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1816
                        ist->file_index, ist->index);
1817
                exit(1);
1818
            }
1819
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1820
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1821
        }
1822
    }
1823

    
1824
    /* init pts */
1825
    for(i=0;i<nb_istreams;i++) {
1826
        ist = ist_table[i];
1827
        is = input_files[ist->file_index];
1828
        ist->pts = 0;
1829
        ist->next_pts = AV_NOPTS_VALUE;
1830
        ist->is_start = 1;
1831
    }
1832

    
1833
    /* set meta data information from input file if required */
1834
    for (i=0;i<nb_meta_data_maps;i++) {
1835
        AVFormatContext *out_file;
1836
        AVFormatContext *in_file;
1837

    
1838
        int out_file_index = meta_data_maps[i].out_file;
1839
        int in_file_index = meta_data_maps[i].in_file;
1840
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1841
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1842
            ret = AVERROR(EINVAL);
1843
            goto fail;
1844
        }
1845
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1846
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1847
            ret = AVERROR(EINVAL);
1848
            goto fail;
1849
        }
1850

    
1851
        out_file = output_files[out_file_index];
1852
        in_file = input_files[in_file_index];
1853

    
1854
        strcpy(out_file->title, in_file->title);
1855
        strcpy(out_file->author, in_file->author);
1856
        strcpy(out_file->copyright, in_file->copyright);
1857
        strcpy(out_file->comment, in_file->comment);
1858
        strcpy(out_file->album, in_file->album);
1859
        out_file->year = in_file->year;
1860
        out_file->track = in_file->track;
1861
        strcpy(out_file->genre, in_file->genre);
1862
    }
1863

    
1864
    /* open files and write file headers */
1865
    for(i=0;i<nb_output_files;i++) {
1866
        os = output_files[i];
1867
        if (av_write_header(os) < 0) {
1868
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1869
            ret = AVERROR(EINVAL);
1870
            goto fail;
1871
        }
1872
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
1873
            want_sdp = 0;
1874
        }
1875
    }
1876
    if (want_sdp) {
1877
        print_sdp(output_files, nb_output_files);
1878
    }
1879

    
1880
    if ( !using_stdin && verbose >= 0) {
1881
        fprintf(stderr, "Press [q] to stop encoding\n");
1882
        url_set_interrupt_cb(decode_interrupt_cb);
1883
    }
1884
    term_init();
1885

    
1886
    key = -1;
1887
    timer_start = av_gettime();
1888

    
1889
    for(; received_sigterm == 0;) {
1890
        int file_index, ist_index;
1891
        AVPacket pkt;
1892
        double ipts_min;
1893
        double opts_min;
1894

    
1895
    redo:
1896
        ipts_min= 1e100;
1897
        opts_min= 1e100;
1898
        /* if 'q' pressed, exits */
1899
        if (!using_stdin) {
1900
            if (q_pressed)
1901
                break;
1902
            /* read_key() returns 0 on EOF */
1903
            key = read_key();
1904
            if (key == 'q')
1905
                break;
1906
        }
1907

    
1908
        /* select the stream that we must read now by looking at the
1909
           smallest output pts */
1910
        file_index = -1;
1911
        for(i=0;i<nb_ostreams;i++) {
1912
            double ipts, opts;
1913
            ost = ost_table[i];
1914
            os = output_files[ost->file_index];
1915
            ist = ist_table[ost->source_index];
1916
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1917
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1918
            else
1919
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1920
            ipts = (double)ist->pts;
1921
            if (!file_table[ist->file_index].eof_reached){
1922
                if(ipts < ipts_min) {
1923
                    ipts_min = ipts;
1924
                    if(input_sync ) file_index = ist->file_index;
1925
                }
1926
                if(opts < opts_min) {
1927
                    opts_min = opts;
1928
                    if(!input_sync) file_index = ist->file_index;
1929
                }
1930
            }
1931
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1932
                file_index= -1;
1933
                break;
1934
            }
1935
        }
1936
        /* if none, if is finished */
1937
        if (file_index < 0) {
1938
            break;
1939
        }
1940

    
1941
        /* finish if recording time exhausted */
1942
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1943
            break;
1944

    
1945
        /* finish if limit size exhausted */
1946
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
1947
            break;
1948

    
1949
        /* read a frame from it and output it in the fifo */
1950
        is = input_files[file_index];
1951
        if (av_read_frame(is, &pkt) < 0) {
1952
            file_table[file_index].eof_reached = 1;
1953
            if (opt_shortest)
1954
                break;
1955
            else
1956
                continue;
1957
        }
1958

    
1959
        if (do_pkt_dump) {
1960
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1961
        }
1962
        /* the following test is needed in case new streams appear
1963
           dynamically in stream : we ignore them */
1964
        if (pkt.stream_index >= file_table[file_index].nb_streams)
1965
            goto discard_packet;
1966
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
1967
        ist = ist_table[ist_index];
1968
        if (ist->discard)
1969
            goto discard_packet;
1970

    
1971
        if (pkt.dts != AV_NOPTS_VALUE)
1972
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1973
        if (pkt.pts != AV_NOPTS_VALUE)
1974
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1975

    
1976
//        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);
1977
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1978
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1979
            int64_t delta= pkt_dts - ist->next_pts;
1980
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1981
                input_files_ts_offset[ist->file_index]-= delta;
1982
                if (verbose > 2)
1983
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1984
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1985
                if(pkt.pts != AV_NOPTS_VALUE)
1986
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1987
            }
1988
        }
1989

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

    
1993
            if (verbose >= 0)
1994
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
1995
                        ist->file_index, ist->index);
1996

    
1997
            av_free_packet(&pkt);
1998
            goto redo;
1999
        }
2000

    
2001
    discard_packet:
2002
        av_free_packet(&pkt);
2003

    
2004
        /* dump report by using the output first video and audio streams */
2005
        print_report(output_files, ost_table, nb_ostreams, 0);
2006
    }
2007

    
2008
    /* at the end of stream, we must flush the decoder buffers */
2009
    for(i=0;i<nb_istreams;i++) {
2010
        ist = ist_table[i];
2011
        if (ist->decoding_needed) {
2012
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2013
        }
2014
    }
2015

    
2016
    term_exit();
2017

    
2018
    /* write the trailer if needed and close file */
2019
    for(i=0;i<nb_output_files;i++) {
2020
        os = output_files[i];
2021
        av_write_trailer(os);
2022
    }
2023

    
2024
    /* dump report by using the first video and audio streams */
2025
    print_report(output_files, ost_table, nb_ostreams, 1);
2026

    
2027
    /* close each encoder */
2028
    for(i=0;i<nb_ostreams;i++) {
2029
        ost = ost_table[i];
2030
        if (ost->encoding_needed) {
2031
            av_freep(&ost->st->codec->stats_in);
2032
            avcodec_close(ost->st->codec);
2033
        }
2034
    }
2035

    
2036
    /* close each decoder */
2037
    for(i=0;i<nb_istreams;i++) {
2038
        ist = ist_table[i];
2039
        if (ist->decoding_needed) {
2040
            avcodec_close(ist->st->codec);
2041
        }
2042
    }
2043

    
2044
    /* finished ! */
2045

    
2046
    ret = 0;
2047
 fail1:
2048
    av_freep(&bit_buffer);
2049
    av_free(file_table);
2050

    
2051
    if (ist_table) {
2052
        for(i=0;i<nb_istreams;i++) {
2053
            ist = ist_table[i];
2054
            av_free(ist);
2055
        }
2056
        av_free(ist_table);
2057
    }
2058
    if (ost_table) {
2059
        for(i=0;i<nb_ostreams;i++) {
2060
            ost = ost_table[i];
2061
            if (ost) {
2062
                if (ost->logfile) {
2063
                    fclose(ost->logfile);
2064
                    ost->logfile = NULL;
2065
                }
2066
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2067
                                             initialized but set to zero */
2068
                av_free(ost->pict_tmp.data[0]);
2069
                if (ost->video_resample)
2070
                    sws_freeContext(ost->img_resample_ctx);
2071
                if (ost->resample)
2072
                    audio_resample_close(ost->resample);
2073
                av_free(ost);
2074
            }
2075
        }
2076
        av_free(ost_table);
2077
    }
2078
    return ret;
2079
 fail:
2080
    ret = AVERROR(ENOMEM);
2081
    goto fail1;
2082
}
2083

    
2084
#if 0
2085
int file_read(const char *filename)
2086
{
2087
    URLContext *h;
2088
    unsigned char buffer[1024];
2089
    int len, i;
2090

2091
    if (url_open(&h, filename, O_RDONLY) < 0) {
2092
        printf("could not open '%s'\n", filename);
2093
        return -1;
2094
    }
2095
    for(;;) {
2096
        len = url_read(h, buffer, sizeof(buffer));
2097
        if (len <= 0)
2098
            break;
2099
        for(i=0;i<len;i++) putchar(buffer[i]);
2100
    }
2101
    url_close(h);
2102
    return 0;
2103
}
2104
#endif
2105

    
2106
static void opt_format(const char *arg)
2107
{
2108
    /* compatibility stuff for pgmyuv */
2109
    if (!strcmp(arg, "pgmyuv")) {
2110
        pgmyuv_compatibility_hack=1;
2111
//        opt_image_format(arg);
2112
        arg = "image2";
2113
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2114
    }
2115

    
2116
    file_iformat = av_find_input_format(arg);
2117
    file_oformat = guess_format(arg, NULL, NULL);
2118
    if (!file_iformat && !file_oformat) {
2119
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2120
        exit(1);
2121
    }
2122
}
2123

    
2124
extern int ffm_nopts;
2125

    
2126
static int opt_default(const char *opt, const char *arg){
2127
    int type;
2128
    const AVOption *o= NULL;
2129
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2130

    
2131
    for(type=0; type<CODEC_TYPE_NB; type++){
2132
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2133
        if(o2)
2134
            o = av_set_string(avctx_opts[type], opt, arg);
2135
    }
2136
    if(!o)
2137
        o = av_set_string(avformat_opts, opt, arg);
2138
    if(!o)
2139
        o = av_set_string(sws_opts, opt, arg);
2140
    if(!o){
2141
        if(opt[0] == 'a')
2142
            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2143
        else if(opt[0] == 'v')
2144
            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2145
        else if(opt[0] == 's')
2146
            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2147
    }
2148
    if(!o)
2149
        return -1;
2150

    
2151
//    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));
2152

    
2153
    //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2154
    opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2155
    opt_names[opt_name_count++]= o->name;
2156

    
2157
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2158
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
2159
    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2160
        ffm_nopts = 1;
2161
#endif
2162

    
2163
    if(avctx_opts[0]->debug)
2164
        av_log_set_level(AV_LOG_DEBUG);
2165
    return 0;
2166
}
2167

    
2168
static void opt_video_rc_override_string(const char *arg)
2169
{
2170
    video_rc_override_string = arg;
2171
}
2172

    
2173
static void opt_me_threshold(const char *arg)
2174
{
2175
    me_threshold = atoi(arg);
2176
}
2177

    
2178
static void opt_verbose(const char *arg)
2179
{
2180
    verbose = atoi(arg);
2181
    av_log_set_level(atoi(arg));
2182
}
2183

    
2184
static void opt_frame_rate(const char *arg)
2185
{
2186
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2187
        fprintf(stderr, "Incorrect frame rate\n");
2188
        exit(1);
2189
    }
2190
}
2191

    
2192
static int opt_bitrate(const char *opt, const char *arg)
2193
{
2194
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2195

    
2196
    opt_default(opt, arg);
2197

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

    
2201
    return 0;
2202
}
2203

    
2204
static void opt_frame_crop_top(const char *arg)
2205
{
2206
    frame_topBand = atoi(arg);
2207
    if (frame_topBand < 0) {
2208
        fprintf(stderr, "Incorrect top crop size\n");
2209
        exit(1);
2210
    }
2211
    if ((frame_topBand % 2) != 0) {
2212
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2213
        exit(1);
2214
    }
2215
    if ((frame_topBand) >= frame_height){
2216
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2217
        exit(1);
2218
    }
2219
    frame_height -= frame_topBand;
2220
}
2221

    
2222
static void opt_frame_crop_bottom(const char *arg)
2223
{
2224
    frame_bottomBand = atoi(arg);
2225
    if (frame_bottomBand < 0) {
2226
        fprintf(stderr, "Incorrect bottom crop size\n");
2227
        exit(1);
2228
    }
2229
    if ((frame_bottomBand % 2) != 0) {
2230
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2231
        exit(1);
2232
    }
2233
    if ((frame_bottomBand) >= frame_height){
2234
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2235
        exit(1);
2236
    }
2237
    frame_height -= frame_bottomBand;
2238
}
2239

    
2240
static void opt_frame_crop_left(const char *arg)
2241
{
2242
    frame_leftBand = atoi(arg);
2243
    if (frame_leftBand < 0) {
2244
        fprintf(stderr, "Incorrect left crop size\n");
2245
        exit(1);
2246
    }
2247
    if ((frame_leftBand % 2) != 0) {
2248
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2249
        exit(1);
2250
    }
2251
    if ((frame_leftBand) >= frame_width){
2252
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2253
        exit(1);
2254
    }
2255
    frame_width -= frame_leftBand;
2256
}
2257

    
2258
static void opt_frame_crop_right(const char *arg)
2259
{
2260
    frame_rightBand = atoi(arg);
2261
    if (frame_rightBand < 0) {
2262
        fprintf(stderr, "Incorrect right crop size\n");
2263
        exit(1);
2264
    }
2265
    if ((frame_rightBand % 2) != 0) {
2266
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2267
        exit(1);
2268
    }
2269
    if ((frame_rightBand) >= frame_width){
2270
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2271
        exit(1);
2272
    }
2273
    frame_width -= frame_rightBand;
2274
}
2275

    
2276
static void opt_frame_size(const char *arg)
2277
{
2278
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2279
        fprintf(stderr, "Incorrect frame size\n");
2280
        exit(1);
2281
    }
2282
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2283
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2284
        exit(1);
2285
    }
2286
}
2287

    
2288

    
2289
#define SCALEBITS 10
2290
#define ONE_HALF  (1 << (SCALEBITS - 1))
2291
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2292

    
2293
#define RGB_TO_Y(r, g, b) \
2294
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2295
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2296

    
2297
#define RGB_TO_U(r1, g1, b1, shift)\
2298
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2299
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2300

    
2301
#define RGB_TO_V(r1, g1, b1, shift)\
2302
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2303
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2304

    
2305
static void opt_pad_color(const char *arg) {
2306
    /* Input is expected to be six hex digits similar to
2307
       how colors are expressed in html tags (but without the #) */
2308
    int rgb = strtol(arg, NULL, 16);
2309
    int r,g,b;
2310

    
2311
    r = (rgb >> 16);
2312
    g = ((rgb >> 8) & 255);
2313
    b = (rgb & 255);
2314

    
2315
    padcolor[0] = RGB_TO_Y(r,g,b);
2316
    padcolor[1] = RGB_TO_U(r,g,b,0);
2317
    padcolor[2] = RGB_TO_V(r,g,b,0);
2318
}
2319

    
2320
static void opt_frame_pad_top(const char *arg)
2321
{
2322
    frame_padtop = atoi(arg);
2323
    if (frame_padtop < 0) {
2324
        fprintf(stderr, "Incorrect top pad size\n");
2325
        exit(1);
2326
    }
2327
    if ((frame_padtop % 2) != 0) {
2328
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2329
        exit(1);
2330
    }
2331
}
2332

    
2333
static void opt_frame_pad_bottom(const char *arg)
2334
{
2335
    frame_padbottom = atoi(arg);
2336
    if (frame_padbottom < 0) {
2337
        fprintf(stderr, "Incorrect bottom pad size\n");
2338
        exit(1);
2339
    }
2340
    if ((frame_padbottom % 2) != 0) {
2341
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2342
        exit(1);
2343
    }
2344
}
2345

    
2346

    
2347
static void opt_frame_pad_left(const char *arg)
2348
{
2349
    frame_padleft = atoi(arg);
2350
    if (frame_padleft < 0) {
2351
        fprintf(stderr, "Incorrect left pad size\n");
2352
        exit(1);
2353
    }
2354
    if ((frame_padleft % 2) != 0) {
2355
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2356
        exit(1);
2357
    }
2358
}
2359

    
2360

    
2361
static void opt_frame_pad_right(const char *arg)
2362
{
2363
    frame_padright = atoi(arg);
2364
    if (frame_padright < 0) {
2365
        fprintf(stderr, "Incorrect right pad size\n");
2366
        exit(1);
2367
    }
2368
    if ((frame_padright % 2) != 0) {
2369
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2370
        exit(1);
2371
    }
2372
}
2373

    
2374
void list_pix_fmts(void)
2375
{
2376
    int i;
2377
    char pix_fmt_str[128];
2378
    for (i=-1; i < PIX_FMT_NB; i++) {
2379
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2380
        fprintf(stdout, "%s\n", pix_fmt_str);
2381
    }
2382
}
2383

    
2384
static void opt_frame_pix_fmt(const char *arg)
2385
{
2386
    if (strcmp(arg, "list"))
2387
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2388
    else {
2389
        list_pix_fmts();
2390
        exit(0);
2391
    }
2392
}
2393

    
2394
static void opt_frame_aspect_ratio(const char *arg)
2395
{
2396
    int x = 0, y = 0;
2397
    double ar = 0;
2398
    const char *p;
2399
    char *end;
2400

    
2401
    p = strchr(arg, ':');
2402
    if (p) {
2403
        x = strtol(arg, &end, 10);
2404
        if (end == p)
2405
            y = strtol(end+1, &end, 10);
2406
        if (x > 0 && y > 0)
2407
            ar = (double)x / (double)y;
2408
    } else
2409
        ar = strtod(arg, NULL);
2410

    
2411
    if (!ar) {
2412
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2413
        exit(1);
2414
    }
2415
    frame_aspect_ratio = ar;
2416
}
2417

    
2418
static void opt_qscale(const char *arg)
2419
{
2420
    video_qscale = atof(arg);
2421
    if (video_qscale <= 0 ||
2422
        video_qscale > 255) {
2423
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2424
        exit(1);
2425
    }
2426
}
2427

    
2428
static void opt_qdiff(const char *arg)
2429
{
2430
    video_qdiff = atoi(arg);
2431
    if (video_qdiff < 0 ||
2432
        video_qdiff > 31) {
2433
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2434
        exit(1);
2435
    }
2436
}
2437

    
2438
static void opt_strict(const char *arg)
2439
{
2440
    strict= atoi(arg);
2441
}
2442

    
2443
static void opt_top_field_first(const char *arg)
2444
{
2445
    top_field_first= atoi(arg);
2446
}
2447

    
2448
static void opt_thread_count(const char *arg)
2449
{
2450
    thread_count= atoi(arg);
2451
#if !defined(HAVE_THREADS)
2452
    if (verbose >= 0)
2453
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2454
#endif
2455
}
2456

    
2457
static void opt_audio_rate(const char *arg)
2458
{
2459
    audio_sample_rate = atoi(arg);
2460
}
2461

    
2462
static void opt_audio_channels(const char *arg)
2463
{
2464
    audio_channels = atoi(arg);
2465
}
2466

    
2467
static void opt_video_channel(const char *arg)
2468
{
2469
    video_channel = strtol(arg, NULL, 0);
2470
}
2471

    
2472
static void opt_video_standard(const char *arg)
2473
{
2474
    video_standard = av_strdup(arg);
2475
}
2476

    
2477
static void opt_codec(int *pstream_copy, char **pcodec_name,
2478
                      int codec_type, const char *arg)
2479
{
2480
    av_freep(pcodec_name);
2481
    if (!strcmp(arg, "copy")) {
2482
        *pstream_copy = 1;
2483
    } else {
2484
        *pcodec_name = av_strdup(arg);
2485
    }
2486
}
2487

    
2488
static void opt_audio_codec(const char *arg)
2489
{
2490
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2491
}
2492

    
2493
static void opt_audio_tag(const char *arg)
2494
{
2495
    char *tail;
2496
    audio_codec_tag= strtol(arg, &tail, 0);
2497

    
2498
    if(!tail || *tail)
2499
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2500
}
2501

    
2502
static void opt_video_tag(const char *arg)
2503
{
2504
    char *tail;
2505
    video_codec_tag= strtol(arg, &tail, 0);
2506

    
2507
    if(!tail || *tail)
2508
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2509
}
2510

    
2511
#ifdef CONFIG_VHOOK
2512
static void add_frame_hooker(const char *arg)
2513
{
2514
    int argc = 0;
2515
    char *argv[64];
2516
    int i;
2517
    char *args = av_strdup(arg);
2518

    
2519
    using_vhook = 1;
2520

    
2521
    argv[0] = strtok(args, " ");
2522
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2523
    }
2524

    
2525
    i = frame_hook_add(argc, argv);
2526

    
2527
    if (i != 0) {
2528
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2529
        exit(1);
2530
    }
2531
}
2532
#endif
2533

    
2534
static void opt_video_codec(const char *arg)
2535
{
2536
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2537
}
2538

    
2539
static void opt_subtitle_codec(const char *arg)
2540
{
2541
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2542
}
2543

    
2544
static void opt_map(const char *arg)
2545
{
2546
    AVStreamMap *m;
2547
    char *p;
2548

    
2549
    m = &stream_maps[nb_stream_maps++];
2550

    
2551
    m->file_index = strtol(arg, &p, 0);
2552
    if (*p)
2553
        p++;
2554

    
2555
    m->stream_index = strtol(p, &p, 0);
2556
    if (*p) {
2557
        p++;
2558
        m->sync_file_index = strtol(p, &p, 0);
2559
        if (*p)
2560
            p++;
2561
        m->sync_stream_index = strtol(p, &p, 0);
2562
    } else {
2563
        m->sync_file_index = m->file_index;
2564
        m->sync_stream_index = m->stream_index;
2565
    }
2566
}
2567

    
2568
static void opt_map_meta_data(const char *arg)
2569
{
2570
    AVMetaDataMap *m;
2571
    char *p;
2572

    
2573
    m = &meta_data_maps[nb_meta_data_maps++];
2574

    
2575
    m->out_file = strtol(arg, &p, 0);
2576
    if (*p)
2577
        p++;
2578

    
2579
    m->in_file = strtol(p, &p, 0);
2580
}
2581

    
2582
static int64_t parse_time_or_die(const char *timestr, int is_duration)
2583
{
2584
    int64_t us = parse_date(timestr, is_duration);
2585
    if (us == INT64_MIN) {
2586
        fprintf(stderr, "Invalid %s specification: %s\n",
2587
                is_duration ? "duration" : "date", timestr);
2588
        exit(1);
2589
    }
2590
    return us;
2591
}
2592

    
2593
static void opt_recording_time(const char *arg)
2594
{
2595
    recording_time = parse_time_or_die(arg, 1);
2596
}
2597

    
2598
static void opt_start_time(const char *arg)
2599
{
2600
    start_time = parse_time_or_die(arg, 1);
2601
}
2602

    
2603
static void opt_rec_timestamp(const char *arg)
2604
{
2605
    rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2606
}
2607

    
2608
static void opt_input_ts_offset(const char *arg)
2609
{
2610
    input_ts_offset = parse_time_or_die(arg, 1);
2611
}
2612

    
2613
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2614
{
2615
    const char *codec_string = encoder ? "encoder" : "decoder";
2616
    AVCodec *codec;
2617

    
2618
    if(!name)
2619
        return CODEC_ID_NONE;
2620
    codec = encoder ?
2621
        avcodec_find_encoder_by_name(name) :
2622
        avcodec_find_decoder_by_name(name);
2623
    if(!codec) {
2624
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2625
        exit(1);
2626
    }
2627
    if(codec->type != type) {
2628
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2629
        exit(1);
2630
    }
2631
    return codec->id;
2632
}
2633

    
2634
static void opt_input_file(const char *filename)
2635
{
2636
    AVFormatContext *ic;
2637
    AVFormatParameters params, *ap = &params;
2638
    int err, i, ret, rfps, rfps_base;
2639
    int64_t timestamp;
2640

    
2641
    if (!strcmp(filename, "-"))
2642
        filename = "pipe:";
2643

    
2644
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2645
                   !strcmp( filename, "/dev/stdin" );
2646

    
2647
    /* get default parameters from command line */
2648
    ic = av_alloc_format_context();
2649

    
2650
    memset(ap, 0, sizeof(*ap));
2651
    ap->prealloced_context = 1;
2652
    ap->sample_rate = audio_sample_rate;
2653
    ap->channels = audio_channels;
2654
    ap->time_base.den = frame_rate.num;
2655
    ap->time_base.num = frame_rate.den;
2656
    ap->width = frame_width + frame_padleft + frame_padright;
2657
    ap->height = frame_height + frame_padtop + frame_padbottom;
2658
    ap->pix_fmt = frame_pix_fmt;
2659
    ap->channel = video_channel;
2660
    ap->standard = video_standard;
2661
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2662
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2663
    if(pgmyuv_compatibility_hack)
2664
        ap->video_codec_id= CODEC_ID_PGMYUV;
2665

    
2666
    for(i=0; i<opt_name_count; i++){
2667
        char buf[256];
2668
        const AVOption *opt;
2669
        const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2670
        if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2671
            av_set_string(ic, opt_names[i], str);
2672
    }
2673

    
2674
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2675
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2676
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2677

    
2678
    /* open the input file with generic libav function */
2679
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2680
    if (err < 0) {
2681
        print_error(filename, err);
2682
        exit(1);
2683
    }
2684
    if(opt_programid) {
2685
        int i;
2686
        for(i=0; i<ic->nb_programs; i++)
2687
            if(ic->programs[i]->id != opt_programid)
2688
                ic->programs[i]->discard = AVDISCARD_ALL;
2689
    }
2690

    
2691
    ic->loop_input = loop_input;
2692

    
2693
    /* If not enough info to get the stream parameters, we decode the
2694
       first frames to get it. (used in mpeg case for example) */
2695
    ret = av_find_stream_info(ic);
2696
    if (ret < 0 && verbose >= 0) {
2697
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2698
        exit(1);
2699
    }
2700

    
2701
    timestamp = start_time;
2702
    /* add the stream start time */
2703
    if (ic->start_time != AV_NOPTS_VALUE)
2704
        timestamp += ic->start_time;
2705

    
2706
    /* if seeking requested, we execute it */
2707
    if (start_time != 0) {
2708
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2709
        if (ret < 0) {
2710
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2711
                    filename, (double)timestamp / AV_TIME_BASE);
2712
        }
2713
        /* reset seek info */
2714
        start_time = 0;
2715
    }
2716

    
2717
    /* update the current parameters so that they match the one of the input stream */
2718
    for(i=0;i<ic->nb_streams;i++) {
2719
        int j;
2720
        AVCodecContext *enc = ic->streams[i]->codec;
2721
        if(thread_count>1)
2722
            avcodec_thread_init(enc, thread_count);
2723
        enc->thread_count= thread_count;
2724
        switch(enc->codec_type) {
2725
        case CODEC_TYPE_AUDIO:
2726
            for(j=0; j<opt_name_count; j++){
2727
                char buf[256];
2728
                const AVOption *opt;
2729
                const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2730
                if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2731
                    av_set_string(enc, opt_names[j], str);
2732
            }
2733
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2734
            audio_channels = enc->channels;
2735
            audio_sample_rate = enc->sample_rate;
2736
            if(audio_disable)
2737
                ic->streams[i]->discard= AVDISCARD_ALL;
2738
            break;
2739
        case CODEC_TYPE_VIDEO:
2740
            for(j=0; j<opt_name_count; j++){
2741
                char buf[256];
2742
                const AVOption *opt;
2743
                const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2744
                if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2745
                    av_set_string(enc, opt_names[j], str);
2746
            }
2747
            frame_height = enc->height;
2748
            frame_width = enc->width;
2749
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2750
            frame_pix_fmt = enc->pix_fmt;
2751
            rfps      = ic->streams[i]->r_frame_rate.num;
2752
            rfps_base = ic->streams[i]->r_frame_rate.den;
2753
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2754
            if(me_threshold)
2755
                enc->debug |= FF_DEBUG_MV;
2756

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

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

    
2763
                    (float)rfps / rfps_base, rfps, rfps_base);
2764
            }
2765
            /* update the current frame rate to match the stream frame rate */
2766
            frame_rate.num = rfps;
2767
            frame_rate.den = rfps_base;
2768

    
2769
            enc->rate_emu = rate_emu;
2770
            if(video_disable)
2771
                ic->streams[i]->discard= AVDISCARD_ALL;
2772
            else if(video_discard)
2773
                ic->streams[i]->discard= video_discard;
2774
            break;
2775
        case CODEC_TYPE_DATA:
2776
            break;
2777
        case CODEC_TYPE_SUBTITLE:
2778
            if(subtitle_disable)
2779
                ic->streams[i]->discard = AVDISCARD_ALL;
2780
            break;
2781
        case CODEC_TYPE_ATTACHMENT:
2782
        case CODEC_TYPE_UNKNOWN:
2783
            break;
2784
        default:
2785
            abort();
2786
        }
2787
    }
2788

    
2789
    input_files[nb_input_files] = ic;
2790
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2791
    /* dump the file content */
2792
    if (verbose >= 0)
2793
        dump_format(ic, nb_input_files, filename, 0);
2794

    
2795
    nb_input_files++;
2796
    file_iformat = NULL;
2797
    file_oformat = NULL;
2798

    
2799
    video_channel = 0;
2800

    
2801
    rate_emu = 0;
2802
    av_freep(&video_codec_name);
2803
    av_freep(&audio_codec_name);
2804
    av_freep(&subtitle_codec_name);
2805
}
2806

    
2807
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2808
                                         int *has_subtitle_ptr)
2809
{
2810
    int has_video, has_audio, has_subtitle, i, j;
2811
    AVFormatContext *ic;
2812

    
2813
    has_video = 0;
2814
    has_audio = 0;
2815
    has_subtitle = 0;
2816
    for(j=0;j<nb_input_files;j++) {
2817
        ic = input_files[j];
2818
        for(i=0;i<ic->nb_streams;i++) {
2819
            AVCodecContext *enc = ic->streams[i]->codec;
2820
            switch(enc->codec_type) {
2821
            case CODEC_TYPE_AUDIO:
2822
                has_audio = 1;
2823
                break;
2824
            case CODEC_TYPE_VIDEO:
2825
                has_video = 1;
2826
                break;
2827
            case CODEC_TYPE_SUBTITLE:
2828
                has_subtitle = 1;
2829
                break;
2830
            case CODEC_TYPE_DATA:
2831
            case CODEC_TYPE_ATTACHMENT:
2832
            case CODEC_TYPE_UNKNOWN:
2833
                break;
2834
            default:
2835
                abort();
2836
            }
2837
        }
2838
    }
2839
    *has_video_ptr = has_video;
2840
    *has_audio_ptr = has_audio;
2841
    *has_subtitle_ptr = has_subtitle;
2842
}
2843

    
2844
static void new_video_stream(AVFormatContext *oc)
2845
{
2846
    AVStream *st;
2847
    AVCodecContext *video_enc;
2848
    int codec_id;
2849

    
2850
    st = av_new_stream(oc, oc->nb_streams);
2851
    if (!st) {
2852
        fprintf(stderr, "Could not alloc stream\n");
2853
        exit(1);
2854
    }
2855
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2856
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2857
    video_bitstream_filters= NULL;
2858

    
2859
    if(thread_count>1)
2860
        avcodec_thread_init(st->codec, thread_count);
2861

    
2862
    video_enc = st->codec;
2863

    
2864
    if(video_codec_tag)
2865
        video_enc->codec_tag= video_codec_tag;
2866

    
2867
    if(   (video_global_header&1)
2868
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2869
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2870
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2871
    }
2872
    if(video_global_header&2){
2873
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2874
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2875
    }
2876

    
2877
    if (video_stream_copy) {
2878
        st->stream_copy = 1;
2879
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2880
    } else {
2881
        const char *p;
2882
        int i;
2883
        AVCodec *codec;
2884
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2885

    
2886
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2887
        if (video_codec_name)
2888
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2889

    
2890
        video_enc->codec_id = codec_id;
2891
        codec = avcodec_find_encoder(codec_id);
2892

    
2893
        for(i=0; i<opt_name_count; i++){
2894
            char buf[256];
2895
            const AVOption *opt;
2896
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2897
            if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2898
                av_set_string(video_enc, opt_names[i], str);
2899
        }
2900

    
2901
        video_enc->time_base.den = fps.num;
2902
        video_enc->time_base.num = fps.den;
2903
        if(codec && codec->supported_framerates){
2904
            const AVRational *p= codec->supported_framerates;
2905
            const AVRational *best=NULL;
2906
            AVRational best_error= (AVRational){INT_MAX, 1};
2907
            for(; p->den!=0; p++){
2908
                AVRational error= av_sub_q(fps, *p);
2909
                if(error.num <0) error.num *= -1;
2910
                if(av_cmp_q(error, best_error) < 0){
2911
                    best_error= error;
2912
                    best= p;
2913
                }
2914
            }
2915
            video_enc->time_base.den= best->num;
2916
            video_enc->time_base.num= best->den;
2917
        }
2918

    
2919
        video_enc->width = frame_width + frame_padright + frame_padleft;
2920
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2921
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2922
        video_enc->pix_fmt = frame_pix_fmt;
2923

    
2924
        if(codec && codec->pix_fmts){
2925
            const enum PixelFormat *p= codec->pix_fmts;
2926
            for(; *p!=-1; p++){
2927
                if(*p == video_enc->pix_fmt)
2928
                    break;
2929
            }
2930
            if(*p == -1)
2931
                video_enc->pix_fmt = codec->pix_fmts[0];
2932
        }
2933

    
2934
        if (intra_only)
2935
            video_enc->gop_size = 0;
2936
        if (video_qscale || same_quality) {
2937
            video_enc->flags |= CODEC_FLAG_QSCALE;
2938
            video_enc->global_quality=
2939
                st->quality = FF_QP2LAMBDA * video_qscale;
2940
        }
2941

    
2942
        if(intra_matrix)
2943
            video_enc->intra_matrix = intra_matrix;
2944
        if(inter_matrix)
2945
            video_enc->inter_matrix = inter_matrix;
2946

    
2947
        video_enc->max_qdiff = video_qdiff;
2948
        video_enc->thread_count = thread_count;
2949
        p= video_rc_override_string;
2950
        for(i=0; p; i++){
2951
            int start, end, q;
2952
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2953
            if(e!=3){
2954
                fprintf(stderr, "error parsing rc_override\n");
2955
                exit(1);
2956
            }
2957
            video_enc->rc_override=
2958
                av_realloc(video_enc->rc_override,
2959
                           sizeof(RcOverride)*(i+1));
2960
            video_enc->rc_override[i].start_frame= start;
2961
            video_enc->rc_override[i].end_frame  = end;
2962
            if(q>0){
2963
                video_enc->rc_override[i].qscale= q;
2964
                video_enc->rc_override[i].quality_factor= 1.0;
2965
            }
2966
            else{
2967
                video_enc->rc_override[i].qscale= 0;
2968
                video_enc->rc_override[i].quality_factor= -q/100.0;
2969
            }
2970
            p= strchr(p, '/');
2971
            if(p) p++;
2972
        }
2973
        video_enc->rc_override_count=i;
2974
        if (!video_enc->rc_initial_buffer_occupancy)
2975
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2976
        video_enc->me_threshold= me_threshold;
2977
        video_enc->intra_dc_precision= intra_dc_precision - 8;
2978
        video_enc->strict_std_compliance = strict;
2979

    
2980
        if (do_psnr)
2981
            video_enc->flags|= CODEC_FLAG_PSNR;
2982

    
2983
        /* two pass mode */
2984
        if (do_pass) {
2985
            if (do_pass == 1) {
2986
                video_enc->flags |= CODEC_FLAG_PASS1;
2987
            } else {
2988
                video_enc->flags |= CODEC_FLAG_PASS2;
2989
            }
2990
        }
2991
    }
2992

    
2993
    /* reset some key parameters */
2994
    video_disable = 0;
2995
    av_freep(&video_codec_name);
2996
    video_stream_copy = 0;
2997
}
2998

    
2999
static void new_audio_stream(AVFormatContext *oc)
3000
{
3001
    AVStream *st;
3002
    AVCodecContext *audio_enc;
3003
    int codec_id, i;
3004

    
3005
    st = av_new_stream(oc, oc->nb_streams);
3006
    if (!st) {
3007
        fprintf(stderr, "Could not alloc stream\n");
3008
        exit(1);
3009
    }
3010
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3011

    
3012
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3013
    audio_bitstream_filters= NULL;
3014

    
3015
    if(thread_count>1)
3016
        avcodec_thread_init(st->codec, thread_count);
3017

    
3018
    audio_enc = st->codec;
3019
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3020
    audio_enc->strict_std_compliance = strict;
3021

    
3022
    if(audio_codec_tag)
3023
        audio_enc->codec_tag= audio_codec_tag;
3024

    
3025
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3026
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3027
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3028
    }
3029
    if (audio_stream_copy) {
3030
        st->stream_copy = 1;
3031
        audio_enc->channels = audio_channels;
3032
    } else {
3033
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3034

    
3035
        for(i=0; i<opt_name_count; i++){
3036
            char buf[256];
3037
            const AVOption *opt;
3038
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3039
            if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3040
                av_set_string(audio_enc, opt_names[i], str);
3041
        }
3042

    
3043
        if (audio_codec_name)
3044
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3045
        audio_enc->codec_id = codec_id;
3046

    
3047
        if (audio_qscale > QSCALE_NONE) {
3048
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3049
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3050
        }
3051
        audio_enc->thread_count = thread_count;
3052
        audio_enc->channels = audio_channels;
3053
    }
3054
    audio_enc->sample_rate = audio_sample_rate;
3055
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3056
    if (audio_language) {
3057
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3058
        av_free(audio_language);
3059
        audio_language = NULL;
3060
    }
3061

    
3062
    /* reset some key parameters */
3063
    audio_disable = 0;
3064
    av_freep(&audio_codec_name);
3065
    audio_stream_copy = 0;
3066
}
3067

    
3068
static void new_subtitle_stream(AVFormatContext *oc)
3069
{
3070
    AVStream *st;
3071
    AVCodecContext *subtitle_enc;
3072
    int i;
3073

    
3074
    st = av_new_stream(oc, oc->nb_streams);
3075
    if (!st) {
3076
        fprintf(stderr, "Could not alloc stream\n");
3077
        exit(1);
3078
    }
3079
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3080

    
3081
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3082
    subtitle_bitstream_filters= NULL;
3083

    
3084
    subtitle_enc = st->codec;
3085
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3086
    if (subtitle_stream_copy) {
3087
        st->stream_copy = 1;
3088
    } else {
3089
        for(i=0; i<opt_name_count; i++){
3090
            char buf[256];
3091
            const AVOption *opt;
3092
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3093
            if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3094
                av_set_string(subtitle_enc, opt_names[i], str);
3095
        }
3096
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3097
    }
3098

    
3099
    if (subtitle_language) {
3100
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3101
        av_free(subtitle_language);
3102
        subtitle_language = NULL;
3103
    }
3104

    
3105
    subtitle_disable = 0;
3106
    av_freep(&subtitle_codec_name);
3107
    subtitle_stream_copy = 0;
3108
}
3109

    
3110
static void opt_new_audio_stream(void)
3111
{
3112
    AVFormatContext *oc;
3113
    if (nb_output_files <= 0) {
3114
        fprintf(stderr, "At least one output file must be specified\n");
3115
        exit(1);
3116
    }
3117
    oc = output_files[nb_output_files - 1];
3118
    new_audio_stream(oc);
3119
}
3120

    
3121
static void opt_new_video_stream(void)
3122
{
3123
    AVFormatContext *oc;
3124
    if (nb_output_files <= 0) {
3125
        fprintf(stderr, "At least one output file must be specified\n");
3126
        exit(1);
3127
    }
3128
    oc = output_files[nb_output_files - 1];
3129
    new_video_stream(oc);
3130
}
3131

    
3132
static void opt_new_subtitle_stream(void)
3133
{
3134
    AVFormatContext *oc;
3135
    if (nb_output_files <= 0) {
3136
        fprintf(stderr, "At least one output file must be specified\n");
3137
        exit(1);
3138
    }
3139
    oc = output_files[nb_output_files - 1];
3140
    new_subtitle_stream(oc);
3141
}
3142

    
3143
static void opt_output_file(const char *filename)
3144
{
3145
    AVFormatContext *oc;
3146
    int use_video, use_audio, use_subtitle;
3147
    int input_has_video, input_has_audio, input_has_subtitle, i;
3148
    AVFormatParameters params, *ap = &params;
3149

    
3150
    if (!strcmp(filename, "-"))
3151
        filename = "pipe:";
3152

    
3153
    oc = av_alloc_format_context();
3154

    
3155
    if (!file_oformat) {
3156
        file_oformat = guess_format(NULL, filename, NULL);
3157
        if (!file_oformat) {
3158
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3159
                    filename);
3160
            exit(1);
3161
        }
3162
    }
3163

    
3164
    oc->oformat = file_oformat;
3165
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3166

    
3167
    if (!strcmp(file_oformat->name, "ffm") &&
3168
        av_strstart(filename, "http:", NULL)) {
3169
        /* special case for files sent to ffserver: we get the stream
3170
           parameters from ffserver */
3171
        if (read_ffserver_streams(oc, filename) < 0) {
3172
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3173
            exit(1);
3174
        }
3175
    } else {
3176
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3177
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3178
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3179

    
3180
        /* disable if no corresponding type found and at least one
3181
           input file */
3182
        if (nb_input_files > 0) {
3183
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3184
                                         &input_has_subtitle);
3185
            if (!input_has_video)
3186
                use_video = 0;
3187
            if (!input_has_audio)
3188
                use_audio = 0;
3189
            if (!input_has_subtitle)
3190
                use_subtitle = 0;
3191
        }
3192

    
3193
        /* manual disable */
3194
        if (audio_disable) {
3195
            use_audio = 0;
3196
        }
3197
        if (video_disable) {
3198
            use_video = 0;
3199
        }
3200
        if (subtitle_disable) {
3201
            use_subtitle = 0;
3202
        }
3203

    
3204
        if (use_video) {
3205
            new_video_stream(oc);
3206
        }
3207

    
3208
        if (use_audio) {
3209
            new_audio_stream(oc);
3210
        }
3211

    
3212
        if (use_subtitle) {
3213
            new_subtitle_stream(oc);
3214
        }
3215

    
3216
        oc->timestamp = rec_timestamp;
3217

    
3218
        if (str_title)
3219
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3220
        if (str_author)
3221
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3222
        if (str_copyright)
3223
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3224
        if (str_comment)
3225
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3226
        if (str_album)
3227
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3228
        if (str_genre)
3229
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3230
    }
3231

    
3232
    output_files[nb_output_files++] = oc;
3233

    
3234
    /* check filename in case of an image number is expected */
3235
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3236
        if (!av_filename_number_test(oc->filename)) {
3237
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3238
            exit(1);
3239
        }
3240
    }
3241

    
3242
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3243
        /* test if it already exists to avoid loosing precious files */
3244
        if (!file_overwrite &&
3245
            (strchr(filename, ':') == NULL ||
3246
             filename[1] == ':' ||
3247
             av_strstart(filename, "file:", NULL))) {
3248
            if (url_exist(filename)) {
3249
                int c;
3250

    
3251
                if ( !using_stdin ) {
3252
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3253
                    fflush(stderr);
3254
                    c = getchar();
3255
                    if (toupper(c) != 'Y') {
3256
                        fprintf(stderr, "Not overwriting - exiting\n");
3257
                        exit(1);
3258
                    }
3259
                                }
3260
                                else {
3261
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3262
                    exit(1);
3263
                                }
3264
            }
3265
        }
3266

    
3267
        /* open the file */
3268
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3269
            fprintf(stderr, "Could not open '%s'\n", filename);
3270
            exit(1);
3271
        }
3272
    }
3273

    
3274
    memset(ap, 0, sizeof(*ap));
3275
    if (av_set_parameters(oc, ap) < 0) {
3276
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3277
                oc->filename);
3278
        exit(1);
3279
    }
3280

    
3281
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3282
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3283
    oc->loop_output = loop_output;
3284

    
3285
    for(i=0; i<opt_name_count; i++){
3286
        char buf[256];
3287
        const AVOption *opt;
3288
        const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3289
        if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3290
            av_set_string(oc, opt_names[i], str);
3291
    }
3292

    
3293
    /* reset some options */
3294
    file_oformat = NULL;
3295
    file_iformat = NULL;
3296
}
3297

    
3298
/* same option as mencoder */
3299
static void opt_pass(const char *pass_str)
3300
{
3301
    int pass;
3302
    pass = atoi(pass_str);
3303
    if (pass != 1 && pass != 2) {
3304
        fprintf(stderr, "pass number can be only 1 or 2\n");
3305
        exit(1);
3306
    }
3307
    do_pass = pass;
3308
}
3309

    
3310
static int64_t getutime(void)
3311
{
3312
#ifdef HAVE_GETRUSAGE
3313
    struct rusage rusage;
3314

    
3315
    getrusage(RUSAGE_SELF, &rusage);
3316
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3317
#elif defined(HAVE_GETPROCESSTIMES)
3318
    HANDLE proc;
3319
    FILETIME c, e, k, u;
3320
    proc = GetCurrentProcess();
3321
    GetProcessTimes(proc, &c, &e, &k, &u);
3322
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3323
#else
3324
    return av_gettime();
3325
#endif
3326
}
3327

    
3328
static void opt_show_formats(void)
3329
{
3330
    AVInputFormat *ifmt=NULL;
3331
    AVOutputFormat *ofmt=NULL;
3332
    URLProtocol *up=NULL;
3333
    AVCodec *p=NULL, *p2;
3334
    AVBitStreamFilter *bsf=NULL;
3335
    const char *last_name;
3336

    
3337
    printf("File formats:\n");
3338
    last_name= "000";
3339
    for(;;){
3340
        int decode=0;
3341
        int encode=0;
3342
        const char *name=NULL;
3343
        const char *long_name=NULL;
3344

    
3345
        while((ofmt= av_oformat_next(ofmt))) {
3346
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3347
                strcmp(ofmt->name, last_name)>0){
3348
                name= ofmt->name;
3349
                long_name= ofmt->long_name;
3350
                encode=1;
3351
            }
3352
        }
3353
        while((ifmt= av_iformat_next(ifmt))) {
3354
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3355
                strcmp(ifmt->name, last_name)>0){
3356
                name= ifmt->name;
3357
                long_name= ifmt->long_name;
3358
                encode=0;
3359
            }
3360
            if(name && strcmp(ifmt->name, name)==0)
3361
                decode=1;
3362
        }
3363
        if(name==NULL)
3364
            break;
3365
        last_name= name;
3366

    
3367
        printf(
3368
            " %s%s %-15s %s\n",
3369
            decode ? "D":" ",
3370
            encode ? "E":" ",
3371
            name,
3372
            long_name ? long_name:" ");
3373
    }
3374
    printf("\n");
3375

    
3376
    printf("Codecs:\n");
3377
    last_name= "000";
3378
    for(;;){
3379
        int decode=0;
3380
        int encode=0;
3381
        int cap=0;
3382
        const char *type_str;
3383

    
3384
        p2=NULL;
3385
        while((p= av_codec_next(p))) {
3386
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3387
                strcmp(p->name, last_name)>0){
3388
                p2= p;
3389
                decode= encode= cap=0;
3390
            }
3391
            if(p2 && strcmp(p->name, p2->name)==0){
3392
                if(p->decode) decode=1;
3393
                if(p->encode) encode=1;
3394
                cap |= p->capabilities;
3395
            }
3396
        }
3397
        if(p2==NULL)
3398
            break;
3399
        last_name= p2->name;
3400

    
3401
        switch(p2->type) {
3402
        case CODEC_TYPE_VIDEO:
3403
            type_str = "V";
3404
            break;
3405
        case CODEC_TYPE_AUDIO:
3406
            type_str = "A";
3407
            break;
3408
        case CODEC_TYPE_SUBTITLE:
3409
            type_str = "S";
3410
            break;
3411
        default:
3412
            type_str = "?";
3413
            break;
3414
        }
3415
        printf(
3416
            " %s%s%s%s%s%s %s",
3417
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3418
            encode ? "E":" ",
3419
            type_str,
3420
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3421
            cap & CODEC_CAP_DR1 ? "D":" ",
3422
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3423
            p2->name);
3424
       /* if(p2->decoder && decode==0)
3425
            printf(" use %s for decoding", p2->decoder->name);*/
3426
        printf("\n");
3427
    }
3428
    printf("\n");
3429

    
3430
    printf("Bitstream filters:\n");
3431
    while((bsf = av_bitstream_filter_next(bsf)))
3432
        printf(" %s", bsf->name);
3433
    printf("\n");
3434

    
3435
    printf("Supported file protocols:\n");
3436
    while((up = av_protocol_next(up)))
3437
        printf(" %s:", up->name);
3438
    printf("\n");
3439

    
3440
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3441
    printf("\n");
3442
    printf(
3443
"Note, the names of encoders and decoders do not always match, so there are\n"
3444
"several cases where the above table shows encoder only or decoder only entries\n"
3445
"even though both encoding and decoding are supported. For example, the h263\n"
3446
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3447
"worse.\n");
3448
    exit(0);
3449
}
3450

    
3451
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3452
{
3453
    int i;
3454
    const char *p = str;
3455
    for(i = 0;; i++) {
3456
        dest[i] = atoi(p);
3457
        if(i == 63)
3458
            break;
3459
        p = strchr(p, ',');
3460
        if(!p) {
3461
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3462
            exit(1);
3463
        }
3464
        p++;
3465
    }
3466
}
3467

    
3468
static void opt_inter_matrix(const char *arg)
3469
{
3470
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3471
    parse_matrix_coeffs(inter_matrix, arg);
3472
}
3473

    
3474
static void opt_intra_matrix(const char *arg)
3475
{
3476
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3477
    parse_matrix_coeffs(intra_matrix, arg);
3478
}
3479

    
3480
/**
3481
 * Trivial log callback.
3482
 * Only suitable for show_help and similar since it lacks prefix handling.
3483
 */
3484
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3485
{
3486
    vfprintf(stdout, fmt, vl);
3487
}
3488

    
3489
static void show_help(void)
3490
{
3491
    av_log_set_callback(log_callback_help);
3492
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3493
           "Hyper fast Audio and Video encoder\n");
3494
    printf("\n");
3495
    show_help_options(options, "Main options:\n",
3496
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3497
    show_help_options(options, "\nVideo options:\n",
3498
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3499
                      OPT_VIDEO);
3500
    show_help_options(options, "\nAdvanced Video options:\n",
3501
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3502
                      OPT_VIDEO | OPT_EXPERT);
3503
    show_help_options(options, "\nAudio options:\n",
3504
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3505
                      OPT_AUDIO);
3506
    show_help_options(options, "\nAdvanced Audio options:\n",
3507
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3508
                      OPT_AUDIO | OPT_EXPERT);
3509
    show_help_options(options, "\nSubtitle options:\n",
3510
                      OPT_SUBTITLE | OPT_GRAB,
3511
                      OPT_SUBTITLE);
3512
    show_help_options(options, "\nAudio/Video grab options:\n",
3513
                      OPT_GRAB,
3514
                      OPT_GRAB);
3515
    show_help_options(options, "\nAdvanced options:\n",
3516
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3517
                      OPT_EXPERT);
3518
    av_opt_show(avctx_opts[0], NULL);
3519
    av_opt_show(avformat_opts, NULL);
3520
    av_opt_show(sws_opts, NULL);
3521
}
3522

    
3523
static void opt_show_help(void)
3524
{
3525
    show_help();
3526
    exit(0);
3527
}
3528

    
3529
static void opt_target(const char *arg)
3530
{
3531
    int norm = -1;
3532
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3533

    
3534
    if(!strncmp(arg, "pal-", 4)) {
3535
        norm = 0;
3536
        arg += 4;
3537
    } else if(!strncmp(arg, "ntsc-", 5)) {
3538
        norm = 1;
3539
        arg += 5;
3540
    } else if(!strncmp(arg, "film-", 5)) {
3541
        norm = 2;
3542
        arg += 5;
3543
    } else {
3544
        int fr;
3545
        /* Calculate FR via float to avoid int overflow */
3546
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3547
        if(fr == 25000) {
3548
            norm = 0;
3549
        } else if((fr == 29970) || (fr == 23976)) {
3550
            norm = 1;
3551
        } else {
3552
            /* Try to determine PAL/NTSC by peeking in the input files */
3553
            if(nb_input_files) {
3554
                int i, j;
3555
                for(j = 0; j < nb_input_files; j++) {
3556
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3557
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3558
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3559
                            continue;
3560
                        fr = c->time_base.den * 1000 / c->time_base.num;
3561
                        if(fr == 25000) {
3562
                            norm = 0;
3563
                            break;
3564
                        } else if((fr == 29970) || (fr == 23976)) {
3565
                            norm = 1;
3566
                            break;
3567
                        }
3568
                    }
3569
                    if(norm >= 0)
3570
                        break;
3571
                }
3572
            }
3573
        }
3574
        if(verbose && norm >= 0)
3575
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3576
    }
3577

    
3578
    if(norm < 0) {
3579
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3580
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3581
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3582
        exit(1);
3583
    }
3584

    
3585
    if(!strcmp(arg, "vcd")) {
3586

    
3587
        opt_video_codec("mpeg1video");
3588
        opt_audio_codec("mp2");
3589
        opt_format("vcd");
3590

    
3591
        opt_frame_size(norm ? "352x240" : "352x288");
3592
        opt_frame_rate(frame_rates[norm]);
3593
        opt_default("gop", norm ? "18" : "15");
3594

    
3595
        opt_default("b", "1150000");
3596
        opt_default("maxrate", "1150000");
3597
        opt_default("minrate", "1150000");
3598
        opt_default("bufsize", "327680"); // 40*1024*8;
3599

    
3600
        opt_default("ab", "224000");
3601
        audio_sample_rate = 44100;
3602
        audio_channels = 2;
3603

    
3604
        opt_default("packetsize", "2324");
3605
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3606

    
3607
        /* We have to offset the PTS, so that it is consistent with the SCR.
3608
           SCR starts at 36000, but the first two packs contain only padding
3609
           and the first pack from the other stream, respectively, may also have
3610
           been written before.
3611
           So the real data starts at SCR 36000+3*1200. */
3612
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3613
    } else if(!strcmp(arg, "svcd")) {
3614

    
3615
        opt_video_codec("mpeg2video");
3616
        opt_audio_codec("mp2");
3617
        opt_format("svcd");
3618

    
3619
        opt_frame_size(norm ? "480x480" : "480x576");
3620
        opt_frame_rate(frame_rates[norm]);
3621
        opt_default("gop", norm ? "18" : "15");
3622

    
3623
        opt_default("b", "2040000");
3624
        opt_default("maxrate", "2516000");
3625
        opt_default("minrate", "0"); //1145000;
3626
        opt_default("bufsize", "1835008"); //224*1024*8;
3627
        opt_default("flags", "+SCAN_OFFSET");
3628

    
3629

    
3630
        opt_default("ab", "224000");
3631
        audio_sample_rate = 44100;
3632

    
3633
        opt_default("packetsize", "2324");
3634

    
3635
    } else if(!strcmp(arg, "dvd")) {
3636

    
3637
        opt_video_codec("mpeg2video");
3638
        opt_audio_codec("ac3");
3639
        opt_format("dvd");
3640

    
3641
        opt_frame_size(norm ? "720x480" : "720x576");
3642
        opt_frame_rate(frame_rates[norm]);
3643
        opt_default("gop", norm ? "18" : "15");
3644

    
3645
        opt_default("b", "6000000");
3646
        opt_default("maxrate", "9000000");
3647
        opt_default("minrate", "0"); //1500000;
3648
        opt_default("bufsize", "1835008"); //224*1024*8;
3649

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

    
3653
        opt_default("ab", "448000");
3654
        audio_sample_rate = 48000;
3655

    
3656
    } else if(!strncmp(arg, "dv", 2)) {
3657

    
3658
        opt_format("dv");
3659

    
3660
        opt_frame_size(norm ? "720x480" : "720x576");
3661
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3662
                                             (norm ? "yuv411p" : "yuv420p"));
3663
        opt_frame_rate(frame_rates[norm]);
3664

    
3665
        audio_sample_rate = 48000;
3666
        audio_channels = 2;
3667

    
3668
    } else {
3669
        fprintf(stderr, "Unknown target: %s\n", arg);
3670
        exit(1);
3671
    }
3672
}
3673

    
3674
static void opt_vstats_file (const char *arg)
3675
{
3676
    av_free (vstats_filename);
3677
    vstats_filename=av_strdup (arg);
3678
}
3679

    
3680
static void opt_vstats (void)
3681
{
3682
    char filename[40];
3683
    time_t today2 = time(NULL);
3684
    struct tm *today = localtime(&today2);
3685

    
3686
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3687
             today->tm_sec);
3688
    opt_vstats_file(filename);
3689
}
3690

    
3691
static int opt_bsf(const char *opt, const char *arg)
3692
{
3693
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3694
    AVBitStreamFilterContext **bsfp;
3695

    
3696
    if(!bsfc){
3697
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3698
        exit(1);
3699
    }
3700

    
3701
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3702
          *opt == 'a' ? &audio_bitstream_filters :
3703
                        &subtitle_bitstream_filters;
3704
    while(*bsfp)
3705
        bsfp= &(*bsfp)->next;
3706

    
3707
    *bsfp= bsfc;
3708

    
3709
    return 0;
3710
}
3711

    
3712
static void opt_show_license(void)
3713
{
3714
    show_license();
3715
    exit(0);
3716
}
3717

    
3718
static void opt_show_version(void)
3719
{
3720
    show_version(program_name);
3721
    exit(0);
3722
}
3723

    
3724
const OptionDef options[] = {
3725
    /* main options */
3726
    { "L", 0, {(void*)opt_show_license}, "show license" },
3727
    { "h", 0, {(void*)opt_show_help}, "show help" },
3728
    { "version", 0, {(void*)opt_show_version}, "show version" },
3729
    { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3730
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3731
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3732
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3733
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3734
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3735
    { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3736
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3737
    { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3738
    { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3739
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3740
    { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3741
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3742
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3743
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3744
    { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3745
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3746
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3747
      "add timings for benchmarking" },
3748
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3749
      "dump each input packet" },
3750
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3751
      "when dumping packets, also dump the payload" },
3752
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3753
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3754
    { "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)", "" },
3755
    { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3756
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3757
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3758
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3759
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3760
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "" },
3761
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3762
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3763
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3764
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3765
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3766

    
3767
    /* video options */
3768
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3769
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3770
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3771
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3772
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3773
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3774
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3775
    { "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" },
3776
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3777
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3778
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3779
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3780
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3781
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3782
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3783
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3784
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3785
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3786
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3787
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3788
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3789
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3790
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3791
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3792
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3793
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3794
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3795
      "use same video quality as source (implies VBR)" },
3796
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3797
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3798
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3799
      "deinterlace pictures" },
3800
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3801
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3802
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3803
#ifdef CONFIG_VHOOK
3804
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3805
#endif
3806
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3807
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3808
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3809
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3810
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3811
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3812
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3813

    
3814
    /* audio options */
3815
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3816
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3817
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3818
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3819
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3820
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3821
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3822
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3823
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3824
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3825
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3826

    
3827
    /* subtitle options */
3828
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3829
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3830
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3831
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3832

    
3833
    /* grab options */
3834
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3835
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3836
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3837

    
3838
    /* muxer options */
3839
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3840
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3841

    
3842
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3843
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3844
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3845

    
3846
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3847
    { NULL, },
3848
};
3849

    
3850
static int av_exit()
3851
{
3852
    int i;
3853

    
3854
    /* close files */
3855
    for(i=0;i<nb_output_files;i++) {
3856
        /* maybe av_close_output_file ??? */
3857
        AVFormatContext *s = output_files[i];
3858
        int j;
3859
        if (!(s->oformat->flags & AVFMT_NOFILE))
3860
            url_fclose(s->pb);
3861
        for(j=0;j<s->nb_streams;j++) {
3862
            av_free(s->streams[j]->codec);
3863
            av_free(s->streams[j]);
3864
        }
3865
        av_free(s);
3866
    }
3867
    for(i=0;i<nb_input_files;i++)
3868
        av_close_input_file(input_files[i]);
3869

    
3870
    av_free_static();
3871

    
3872
    av_free(intra_matrix);
3873
    av_free(inter_matrix);
3874

    
3875
    if (vstats_file)
3876
        fclose(vstats_file);
3877
    av_free(vstats_filename);
3878

    
3879
    av_free(opt_names);
3880

    
3881
    av_free(video_codec_name);
3882
    av_free(audio_codec_name);
3883
    av_free(subtitle_codec_name);
3884

    
3885
    av_free(video_standard);
3886

    
3887
#ifdef CONFIG_POWERPC_PERF
3888
    extern void powerpc_display_perf_report(void);
3889
    powerpc_display_perf_report();
3890
#endif /* CONFIG_POWERPC_PERF */
3891

    
3892
    if (received_sigterm) {
3893
        fprintf(stderr,
3894
            "Received signal %d: terminating.\n",
3895
            (int) received_sigterm);
3896
        exit (255);
3897
    }
3898

    
3899
    exit(0); /* not all OS-es handle main() return value */
3900
    return 0;
3901
}
3902

    
3903
int main(int argc, char **argv)
3904
{
3905
    int i;
3906
    int64_t ti;
3907

    
3908
    avcodec_register_all();
3909
    avdevice_register_all();
3910
    av_register_all();
3911

    
3912
    for(i=0; i<CODEC_TYPE_NB; i++){
3913
        avctx_opts[i]= avcodec_alloc_context2(i);
3914
    }
3915
    avformat_opts = av_alloc_format_context();
3916
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3917

    
3918
    show_banner(program_name, program_birth_year);
3919
    if (argc <= 1) {
3920
        show_help();
3921
        exit(1);
3922
    }
3923

    
3924
    /* parse options */
3925
    parse_options(argc, argv, options, opt_output_file);
3926

    
3927
    /* file converter / grab */
3928
    if (nb_output_files <= 0) {
3929
        fprintf(stderr, "Must supply at least one output file\n");
3930
        exit(1);
3931
    }
3932

    
3933
    if (nb_input_files == 0) {
3934
        fprintf(stderr, "Must supply at least one input file\n");
3935
        exit(1);
3936
    }
3937

    
3938
    ti = getutime();
3939
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3940
              stream_maps, nb_stream_maps);
3941
    ti = getutime() - ti;
3942
    if (do_benchmark) {
3943
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3944
    }
3945

    
3946
    return av_exit();
3947
}