Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ b1b818fc

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 (pkt == NULL) {
1059
        /* EOF handling */
1060
        ptr = NULL;
1061
        len = 0;
1062
        goto handle_eof;
1063
    }
1064

    
1065
    if(pkt->dts != AV_NOPTS_VALUE)
1066
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1067

    
1068
    len = pkt->size;
1069
    ptr = pkt->data;
1070
    while (len > 0) {
1071
    handle_eof:
1072
        ist->pts= ist->next_pts;
1073

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

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

    
1157
        buffer_to_free = NULL;
1158
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1159
            pre_process_video_frame(ist, (AVPicture *)&picture,
1160
                                    &buffer_to_free);
1161
        }
1162

    
1163
        // preprocess audio (volume)
1164
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1165
            if (audio_volume != 256) {
1166
                short *volp;
1167
                volp = samples;
1168
                for(i=0;i<(data_size / sizeof(short));i++) {
1169
                    int v = ((*volp) * audio_volume + 128) >> 8;
1170
                    if (v < -32768) v = -32768;
1171
                    if (v >  32767) v = 32767;
1172
                    *volp++ = v;
1173
                }
1174
            }
1175
        }
1176

    
1177
        /* frame rate emulation */
1178
        if (ist->st->codec->rate_emu) {
1179
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1180
            int64_t now = av_gettime() - ist->start;
1181
            if (pts > now)
1182
                usleep(pts - now);
1183

    
1184
            ist->frame++;
1185
        }
1186

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

    
1206
                ost = ost_table[i];
1207
                if (ost->source_index == ist_index) {
1208
                    os = output_files[ost->file_index];
1209

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

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

    
1242
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1243
                            continue;
1244

    
1245
                        /* no reencoding needed : output the packet directly */
1246
                        /* force the input stream PTS */
1247

    
1248
                        avcodec_get_frame_defaults(&avframe);
1249
                        ost->st->codec->coded_frame= &avframe;
1250
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1251

    
1252
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1253
                            audio_size += data_size;
1254
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1255
                            video_size += data_size;
1256
                            ost->sync_opts++;
1257
                        }
1258

    
1259
                        opkt.stream_index= ost->index;
1260
                        if(pkt->pts != AV_NOPTS_VALUE)
1261
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1262
                        else
1263
                            opkt.pts= AV_NOPTS_VALUE;
1264

    
1265
                            if (pkt->dts == AV_NOPTS_VALUE)
1266
                                opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1267
                            else
1268
                                opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1269

    
1270
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1271
                        opkt.flags= pkt->flags;
1272

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

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

    
1302
        for(i=0;i<nb_ostreams;i++) {
1303
            ost = ost_table[i];
1304
            if (ost->source_index == ist_index) {
1305
                AVCodecContext *enc= ost->st->codec;
1306
                os = output_files[ost->file_index];
1307

    
1308
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1309
                    continue;
1310
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1311
                    continue;
1312

    
1313
                if (ost->encoding_needed) {
1314
                    for(;;) {
1315
                        AVPacket pkt;
1316
                        int fifo_bytes;
1317
                        av_init_packet(&pkt);
1318
                        pkt.stream_index= ost->index;
1319

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

    
1352
                        if(ret<=0)
1353
                            break;
1354
                        pkt.data= bit_buffer;
1355
                        pkt.size= ret;
1356
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1357
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1358
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1359
                    }
1360
                }
1361
            }
1362
        }
1363
    }
1364

    
1365
    return 0;
1366
 fail_decode:
1367
    return -1;
1368
}
1369

    
1370
static void print_sdp(AVFormatContext **avc, int n)
1371
{
1372
    char sdp[2048];
1373

    
1374
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1375
    printf("SDP:\n%s\n", sdp);
1376
}
1377

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

    
1401
    return -1;
1402
}
1403

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

    
1422
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1423
    if (!file_table)
1424
        goto fail;
1425

    
1426
    /* input stream init */
1427
    j = 0;
1428
    for(i=0;i<nb_input_files;i++) {
1429
        is = input_files[i];
1430
        file_table[i].ist_index = j;
1431
        file_table[i].nb_streams = is->nb_streams;
1432
        j += is->nb_streams;
1433
    }
1434
    nb_istreams = j;
1435

    
1436
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1437
    if (!ist_table)
1438
        goto fail;
1439

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

    
1457
            if (ist->st->codec->rate_emu) {
1458
                ist->start = av_gettime();
1459
                ist->frame = 0;
1460
            }
1461
        }
1462
    }
1463

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

    
1479
    /* Sanity check the mapping args -- do the input files & streams exist? */
1480
    for(i=0;i<nb_stream_maps;i++) {
1481
        int fi = stream_maps[i].file_index;
1482
        int si = stream_maps[i].stream_index;
1483

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

    
1498
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1499
    if (!ost_table)
1500
        goto fail;
1501
    for(i=0;i<nb_ostreams;i++) {
1502
        ost = av_mallocz(sizeof(AVOutputStream));
1503
        if (!ost)
1504
            goto fail;
1505
        ost_table[i] = ost;
1506
    }
1507

    
1508
    n = 0;
1509
    for(k=0;k<nb_output_files;k++) {
1510
        os = output_files[k];
1511
        for(i=0;i<os->nb_streams;i++) {
1512
            int found;
1513
            ost = ost_table[n++];
1514
            ost->file_index = k;
1515
            ost->index = i;
1516
            ost->st = os->streams[i];
1517
            if (nb_stream_maps > 0) {
1518
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1519
                    stream_maps[n-1].stream_index;
1520

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

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

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

    
1577
    /* for each output stream, we compute the right encoding parameters */
1578
    for(i=0;i<nb_ostreams;i++) {
1579
        ost = ost_table[i];
1580
        os = output_files[ost->file_index];
1581
        ist = ist_table[ost->source_index];
1582

    
1583
        codec = ost->st->codec;
1584
        icodec = ist->st->codec;
1585

    
1586
        if (!ost->st->language[0])
1587
            av_strlcpy(ost->st->language, ist->st->language,
1588
                       sizeof(ost->st->language));
1589

    
1590
        if (ost->st->stream_copy) {
1591
            /* if stream_copy is selected, no need to decode or encode */
1592
            codec->codec_id = icodec->codec_id;
1593
            codec->codec_type = icodec->codec_type;
1594

    
1595
            if(!codec->codec_tag){
1596
                if(   !os->oformat->codec_tag
1597
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1598
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1599
                    codec->codec_tag = icodec->codec_tag;
1600
            }
1601

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

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

    
1748
    if (!bit_buffer)
1749
        bit_buffer = av_malloc(bit_buffer_size);
1750
    if (!bit_buffer)
1751
        goto fail;
1752

    
1753
    /* dump the file output parameters - cannot be done before in case
1754
       of stream copy */
1755
    for(i=0;i<nb_output_files;i++) {
1756
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1757
    }
1758

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

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

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

    
1818
    /* init pts */
1819
    for(i=0;i<nb_istreams;i++) {
1820
        ist = ist_table[i];
1821
        is = input_files[ist->file_index];
1822
        ist->pts = 0;
1823
        ist->next_pts=0;
1824
        if(   input_files_ts_offset[ist->file_index] != -is->start_time
1825
           && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))
1826
            ist->next_pts= AV_NOPTS_VALUE;
1827
        ist->is_start = 1;
1828
    }
1829

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

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

    
1848
        out_file = output_files[out_file_index];
1849
        in_file = input_files[in_file_index];
1850

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

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

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

    
1883
    key = -1;
1884
    timer_start = av_gettime();
1885

    
1886
    for(; received_sigterm == 0;) {
1887
        int file_index, ist_index;
1888
        AVPacket pkt;
1889
        double ipts_min;
1890
        double opts_min;
1891

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

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

    
1938
        /* finish if recording time exhausted */
1939
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1940
            break;
1941

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

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

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

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

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

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

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

    
1994
            av_free_packet(&pkt);
1995
            goto redo;
1996
        }
1997

    
1998
    discard_packet:
1999
        av_free_packet(&pkt);
2000

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

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

    
2013
    term_exit();
2014

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

    
2021
    /* dump report by using the first video and audio streams */
2022
    print_report(output_files, ost_table, nb_ostreams, 1);
2023

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

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

    
2041
    /* finished ! */
2042

    
2043
    ret = 0;
2044
 fail1:
2045
    av_freep(&bit_buffer);
2046
    av_free(file_table);
2047

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

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

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

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

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

    
2121
extern int ffm_nopts;
2122

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

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

    
2148
//    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));
2149

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

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

    
2160
    if(avctx_opts[0]->debug)
2161
        av_log_set_level(AV_LOG_DEBUG);
2162
    return 0;
2163
}
2164

    
2165
static void opt_video_rc_override_string(const char *arg)
2166
{
2167
    video_rc_override_string = arg;
2168
}
2169

    
2170
static void opt_me_threshold(const char *arg)
2171
{
2172
    me_threshold = atoi(arg);
2173
}
2174

    
2175
static void opt_verbose(const char *arg)
2176
{
2177
    verbose = atoi(arg);
2178
    av_log_set_level(atoi(arg));
2179
}
2180

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

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

    
2193
    opt_default(opt, arg);
2194

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

    
2198
    return 0;
2199
}
2200

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

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

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

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

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

    
2285

    
2286
#define SCALEBITS 10
2287
#define ONE_HALF  (1 << (SCALEBITS - 1))
2288
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2289

    
2290
#define RGB_TO_Y(r, g, b) \
2291
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2292
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2293

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

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

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

    
2308
    r = (rgb >> 16);
2309
    g = ((rgb >> 8) & 255);
2310
    b = (rgb & 255);
2311

    
2312
    padcolor[0] = RGB_TO_Y(r,g,b);
2313
    padcolor[1] = RGB_TO_U(r,g,b,0);
2314
    padcolor[2] = RGB_TO_V(r,g,b,0);
2315
}
2316

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

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

    
2343

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

    
2357

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

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

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

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

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

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

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

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

    
2435
static void opt_strict(const char *arg)
2436
{
2437
    strict= atoi(arg);
2438
}
2439

    
2440
static void opt_top_field_first(const char *arg)
2441
{
2442
    top_field_first= atoi(arg);
2443
}
2444

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

    
2454
static void opt_audio_rate(const char *arg)
2455
{
2456
    audio_sample_rate = atoi(arg);
2457
}
2458

    
2459
static void opt_audio_channels(const char *arg)
2460
{
2461
    audio_channels = atoi(arg);
2462
}
2463

    
2464
static void opt_video_channel(const char *arg)
2465
{
2466
    video_channel = strtol(arg, NULL, 0);
2467
}
2468

    
2469
static void opt_video_standard(const char *arg)
2470
{
2471
    video_standard = av_strdup(arg);
2472
}
2473

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

    
2485
static void opt_audio_codec(const char *arg)
2486
{
2487
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2488
}
2489

    
2490
static void opt_audio_tag(const char *arg)
2491
{
2492
    char *tail;
2493
    audio_codec_tag= strtol(arg, &tail, 0);
2494

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

    
2499
static void opt_video_tag(const char *arg)
2500
{
2501
    char *tail;
2502
    video_codec_tag= strtol(arg, &tail, 0);
2503

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

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

    
2516
    using_vhook = 1;
2517

    
2518
    argv[0] = strtok(args, " ");
2519
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2520
    }
2521

    
2522
    i = frame_hook_add(argc, argv);
2523

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

    
2531
static void opt_video_codec(const char *arg)
2532
{
2533
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2534
}
2535

    
2536
static void opt_subtitle_codec(const char *arg)
2537
{
2538
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2539
}
2540

    
2541
static void opt_map(const char *arg)
2542
{
2543
    AVStreamMap *m;
2544
    char *p;
2545

    
2546
    m = &stream_maps[nb_stream_maps++];
2547

    
2548
    m->file_index = strtol(arg, &p, 0);
2549
    if (*p)
2550
        p++;
2551

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

    
2565
static void opt_map_meta_data(const char *arg)
2566
{
2567
    AVMetaDataMap *m;
2568
    char *p;
2569

    
2570
    m = &meta_data_maps[nb_meta_data_maps++];
2571

    
2572
    m->out_file = strtol(arg, &p, 0);
2573
    if (*p)
2574
        p++;
2575

    
2576
    m->in_file = strtol(p, &p, 0);
2577
}
2578

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

    
2590
static void opt_recording_time(const char *arg)
2591
{
2592
    recording_time = parse_time_or_die(arg, 1);
2593
}
2594

    
2595
static void opt_start_time(const char *arg)
2596
{
2597
    start_time = parse_time_or_die(arg, 1);
2598
}
2599

    
2600
static void opt_rec_timestamp(const char *arg)
2601
{
2602
    rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2603
}
2604

    
2605
static void opt_input_ts_offset(const char *arg)
2606
{
2607
    input_ts_offset = parse_time_or_die(arg, 1);
2608
}
2609

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

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

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

    
2638
    if (!strcmp(filename, "-"))
2639
        filename = "pipe:";
2640

    
2641
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2642
                   !strcmp( filename, "/dev/stdin" );
2643

    
2644
    /* get default parameters from command line */
2645
    ic = av_alloc_format_context();
2646

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

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

    
2671
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2672
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2673
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2674

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

    
2688
    ic->loop_input = loop_input;
2689

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

    
2698
    timestamp = start_time;
2699
    /* add the stream start time */
2700
    if (ic->start_time != AV_NOPTS_VALUE)
2701
        timestamp += ic->start_time;
2702

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

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

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

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

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

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

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

    
2792
    nb_input_files++;
2793
    file_iformat = NULL;
2794
    file_oformat = NULL;
2795

    
2796
    video_channel = 0;
2797

    
2798
    rate_emu = 0;
2799
    av_freep(&video_codec_name);
2800
    av_freep(&audio_codec_name);
2801
    av_freep(&subtitle_codec_name);
2802
}
2803

    
2804
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2805
                                         int *has_subtitle_ptr)
2806
{
2807
    int has_video, has_audio, has_subtitle, i, j;
2808
    AVFormatContext *ic;
2809

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

    
2841
static void new_video_stream(AVFormatContext *oc)
2842
{
2843
    AVStream *st;
2844
    AVCodecContext *video_enc;
2845
    int codec_id;
2846

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

    
2856
    if(thread_count>1)
2857
        avcodec_thread_init(st->codec, thread_count);
2858

    
2859
    video_enc = st->codec;
2860

    
2861
    if(video_codec_tag)
2862
        video_enc->codec_tag= video_codec_tag;
2863

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

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

    
2883
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2884
        if (video_codec_name)
2885
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2886

    
2887
        video_enc->codec_id = codec_id;
2888
        codec = avcodec_find_encoder(codec_id);
2889

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

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

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

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

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

    
2939
        if(intra_matrix)
2940
            video_enc->intra_matrix = intra_matrix;
2941
        if(inter_matrix)
2942
            video_enc->inter_matrix = inter_matrix;
2943

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

    
2977
        if (do_psnr)
2978
            video_enc->flags|= CODEC_FLAG_PSNR;
2979

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

    
2990
    /* reset some key parameters */
2991
    video_disable = 0;
2992
    av_freep(&video_codec_name);
2993
    video_stream_copy = 0;
2994
}
2995

    
2996
static void new_audio_stream(AVFormatContext *oc)
2997
{
2998
    AVStream *st;
2999
    AVCodecContext *audio_enc;
3000
    int codec_id, i;
3001

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

    
3009
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3010
    audio_bitstream_filters= NULL;
3011

    
3012
    if(thread_count>1)
3013
        avcodec_thread_init(st->codec, thread_count);
3014

    
3015
    audio_enc = st->codec;
3016
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3017
    audio_enc->strict_std_compliance = strict;
3018

    
3019
    if(audio_codec_tag)
3020
        audio_enc->codec_tag= audio_codec_tag;
3021

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

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

    
3040
        if (audio_codec_name)
3041
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3042
        audio_enc->codec_id = codec_id;
3043

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

    
3059
    /* reset some key parameters */
3060
    audio_disable = 0;
3061
    av_freep(&audio_codec_name);
3062
    audio_stream_copy = 0;
3063
}
3064

    
3065
static void new_subtitle_stream(AVFormatContext *oc)
3066
{
3067
    AVStream *st;
3068
    AVCodecContext *subtitle_enc;
3069
    int i;
3070

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

    
3078
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3079
    subtitle_bitstream_filters= NULL;
3080

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

    
3096
    if (subtitle_language) {
3097
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3098
        av_free(subtitle_language);
3099
        subtitle_language = NULL;
3100
    }
3101

    
3102
    subtitle_disable = 0;
3103
    av_freep(&subtitle_codec_name);
3104
    subtitle_stream_copy = 0;
3105
}
3106

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

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

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

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

    
3147
    if (!strcmp(filename, "-"))
3148
        filename = "pipe:";
3149

    
3150
    oc = av_alloc_format_context();
3151

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

    
3161
    oc->oformat = file_oformat;
3162
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3163

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

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

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

    
3201
        if (use_video) {
3202
            new_video_stream(oc);
3203
        }
3204

    
3205
        if (use_audio) {
3206
            new_audio_stream(oc);
3207
        }
3208

    
3209
        if (use_subtitle) {
3210
            new_subtitle_stream(oc);
3211
        }
3212

    
3213
        oc->timestamp = rec_timestamp;
3214

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

    
3229
    output_files[nb_output_files++] = oc;
3230

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

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

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

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

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

    
3278
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3279
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3280
    oc->loop_output = loop_output;
3281

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

    
3290
    /* reset some options */
3291
    file_oformat = NULL;
3292
    file_iformat = NULL;
3293
}
3294

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

    
3307
static int64_t getutime(void)
3308
{
3309
#ifdef HAVE_GETRUSAGE
3310
    struct rusage rusage;
3311

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

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

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

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

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

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

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

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

    
3427
    printf("Bitstream filters:\n");
3428
    while((bsf = av_bitstream_filter_next(bsf)))
3429
        printf(" %s", bsf->name);
3430
    printf("\n");
3431

    
3432
    printf("Supported file protocols:\n");
3433
    while((up = av_protocol_next(up)))
3434
        printf(" %s:", up->name);
3435
    printf("\n");
3436

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

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

    
3465
static void opt_inter_matrix(const char *arg)
3466
{
3467
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3468
    parse_matrix_coeffs(inter_matrix, arg);
3469
}
3470

    
3471
static void opt_intra_matrix(const char *arg)
3472
{
3473
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3474
    parse_matrix_coeffs(intra_matrix, arg);
3475
}
3476

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

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

    
3520
static void opt_show_help(void)
3521
{
3522
    show_help();
3523
    exit(0);
3524
}
3525

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

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

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

    
3582
    if(!strcmp(arg, "vcd")) {
3583

    
3584
        opt_video_codec("mpeg1video");
3585
        opt_audio_codec("mp2");
3586
        opt_format("vcd");
3587

    
3588
        opt_frame_size(norm ? "352x240" : "352x288");
3589
        opt_frame_rate(frame_rates[norm]);
3590
        opt_default("gop", norm ? "18" : "15");
3591

    
3592
        opt_default("b", "1150000");
3593
        opt_default("maxrate", "1150000");
3594
        opt_default("minrate", "1150000");
3595
        opt_default("bufsize", "327680"); // 40*1024*8;
3596

    
3597
        opt_default("ab", "224000");
3598
        audio_sample_rate = 44100;
3599
        audio_channels = 2;
3600

    
3601
        opt_default("packetsize", "2324");
3602
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3603

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

    
3612
        opt_video_codec("mpeg2video");
3613
        opt_audio_codec("mp2");
3614
        opt_format("svcd");
3615

    
3616
        opt_frame_size(norm ? "480x480" : "480x576");
3617
        opt_frame_rate(frame_rates[norm]);
3618
        opt_default("gop", norm ? "18" : "15");
3619

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

    
3626

    
3627
        opt_default("ab", "224000");
3628
        audio_sample_rate = 44100;
3629

    
3630
        opt_default("packetsize", "2324");
3631

    
3632
    } else if(!strcmp(arg, "dvd")) {
3633

    
3634
        opt_video_codec("mpeg2video");
3635
        opt_audio_codec("ac3");
3636
        opt_format("dvd");
3637

    
3638
        opt_frame_size(norm ? "720x480" : "720x576");
3639
        opt_frame_rate(frame_rates[norm]);
3640
        opt_default("gop", norm ? "18" : "15");
3641

    
3642
        opt_default("b", "6000000");
3643
        opt_default("maxrate", "9000000");
3644
        opt_default("minrate", "0"); //1500000;
3645
        opt_default("bufsize", "1835008"); //224*1024*8;
3646

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

    
3650
        opt_default("ab", "448000");
3651
        audio_sample_rate = 48000;
3652

    
3653
    } else if(!strncmp(arg, "dv", 2)) {
3654

    
3655
        opt_format("dv");
3656

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

    
3662
        audio_sample_rate = 48000;
3663
        audio_channels = 2;
3664

    
3665
    } else {
3666
        fprintf(stderr, "Unknown target: %s\n", arg);
3667
        exit(1);
3668
    }
3669
}
3670

    
3671
static void opt_vstats_file (const char *arg)
3672
{
3673
    av_free (vstats_filename);
3674
    vstats_filename=av_strdup (arg);
3675
}
3676

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

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

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

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

    
3698
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3699
          *opt == 'a' ? &audio_bitstream_filters :
3700
                        &subtitle_bitstream_filters;
3701
    while(*bsfp)
3702
        bsfp= &(*bsfp)->next;
3703

    
3704
    *bsfp= bsfc;
3705

    
3706
    return 0;
3707
}
3708

    
3709
static void opt_show_license(void)
3710
{
3711
    show_license();
3712
    exit(0);
3713
}
3714

    
3715
static void opt_show_version(void)
3716
{
3717
    show_version(program_name);
3718
    exit(0);
3719
}
3720

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

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

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

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

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

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

    
3839
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3840
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3841
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3842

    
3843
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3844
    { NULL, },
3845
};
3846

    
3847
static int av_exit()
3848
{
3849
    int i;
3850

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

    
3867
    av_free_static();
3868

    
3869
    av_free(intra_matrix);
3870
    av_free(inter_matrix);
3871

    
3872
    if (vstats_file)
3873
        fclose(vstats_file);
3874
    av_free(vstats_filename);
3875

    
3876
    av_free(opt_names);
3877

    
3878
    av_free(video_codec_name);
3879
    av_free(audio_codec_name);
3880
    av_free(subtitle_codec_name);
3881

    
3882
    av_free(video_standard);
3883

    
3884
#ifdef CONFIG_POWERPC_PERF
3885
    extern void powerpc_display_perf_report(void);
3886
    powerpc_display_perf_report();
3887
#endif /* CONFIG_POWERPC_PERF */
3888

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

    
3896
    exit(0); /* not all OS-es handle main() return value */
3897
    return 0;
3898
}
3899

    
3900
int main(int argc, char **argv)
3901
{
3902
    int i;
3903
    int64_t ti;
3904

    
3905
    avcodec_register_all();
3906
    avdevice_register_all();
3907
    av_register_all();
3908

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

    
3915
    show_banner(program_name, program_birth_year);
3916
    if (argc <= 1) {
3917
        show_help();
3918
        exit(1);
3919
    }
3920

    
3921
    /* parse options */
3922
    parse_options(argc, argv, options, opt_output_file);
3923

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

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

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

    
3943
    return av_exit();
3944
}