Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ e5295c0d

History | View | Annotate | Download (137 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
#undef exit
63

    
64
static const char program_name[] = "FFmpeg";
65
static const int program_birth_year = 2000;
66

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

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

    
81
extern const OptionDef options[];
82

    
83
#define MAX_FILES 20
84

    
85
static AVFormatContext *input_files[MAX_FILES];
86
static int64_t input_files_ts_offset[MAX_FILES];
87
static int nb_input_files = 0;
88

    
89
static AVFormatContext *output_files[MAX_FILES];
90
static int nb_output_files = 0;
91

    
92
static AVStreamMap stream_maps[MAX_FILES];
93
static int nb_stream_maps;
94

    
95
static AVMetaDataMap meta_data_maps[MAX_FILES];
96
static int nb_meta_data_maps;
97

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

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

    
149
static int subtitle_disable = 0;
150
static char *subtitle_codec_name = NULL;
151
static char *subtitle_language = NULL;
152

    
153
static float mux_preload= 0.5;
154
static float mux_max_delay= 0.7;
155

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

    
186
static int rate_emu = 0;
187

    
188
static int  video_channel = 0;
189
static char *video_standard;
190

    
191
static int audio_volume = 256;
192

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

    
206
static int pgmyuv_compatibility_hack=0;
207
static float dts_delta_threshold = 10;
208

    
209
static unsigned int sws_flags = SWS_BICUBIC;
210

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

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

    
223
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
224

    
225
struct AVInputStream;
226

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

    
245
    int video_crop;
246
    int topBand;             /* cropping area sizes */
247
    int leftBand;
248

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

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

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

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

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

    
285
#ifdef HAVE_TERMIOS_H
286

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

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

    
298
static volatile sig_atomic_t received_sigterm = 0;
299

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

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

    
312
    tcgetattr (0, &tty);
313
    oldtty = tty;
314

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

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

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

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

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

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

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

    
374
static int av_exit()
375
{
376
    int i;
377

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

    
394
    av_free_static();
395

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

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

    
403
    av_free(opt_names);
404

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

    
409
    av_free(video_standard);
410

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

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

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

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

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

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

    
448
    av_close_input_file(ic);
449
    return 0;
450
}
451

    
452
static double
453
get_sync_ipts(const AVOutputStream *ost)
454
{
455
    const AVInputStream *ist = ost->sync_ist;
456
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
457
}
458

    
459
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
460
    int ret;
461

    
462
    while(bsfc){
463
        AVPacket new_pkt= *pkt;
464
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
465
                                          &new_pkt.data, &new_pkt.size,
466
                                          pkt->data, pkt->size,
467
                                          pkt->flags & PKT_FLAG_KEY);
468
        if(a>0){
469
            av_free_packet(pkt);
470
            new_pkt.destruct= av_destruct_packet;
471
        } else if(a<0){
472
            fprintf(stderr, "%s failed for stream %d, codec %s",
473
                    bsfc->filter->name, pkt->stream_index,
474
                    avctx->codec ? avctx->codec->name : "copy");
475
            print_error("", a);
476
        }
477
        *pkt= new_pkt;
478

    
479
        bsfc= bsfc->next;
480
    }
481

    
482
    ret= av_interleaved_write_frame(s, pkt);
483
    if(ret < 0){
484
        print_error("av_interleaved_write_frame()", ret);
485
        exit(1);
486
    }
487
}
488

    
489
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
490

    
491
static void do_audio_out(AVFormatContext *s,
492
                         AVOutputStream *ost,
493
                         AVInputStream *ist,
494
                         unsigned char *buf, int size)
495
{
496
    uint8_t *buftmp;
497
    static uint8_t *audio_buf = NULL;
498
    static uint8_t *audio_out = NULL;
499
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
500

    
501
    int size_out, frame_bytes, ret;
502
    AVCodecContext *enc= ost->st->codec;
503
    AVCodecContext *dec= ist->st->codec;
504

    
505
    /* SC: dynamic allocation of buffers */
506
    if (!audio_buf)
507
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
508
    if (!audio_out)
509
        audio_out = av_malloc(audio_out_size);
510
    if (!audio_buf || !audio_out)
511
        return;               /* Should signal an error ! */
512

    
513
    if (enc->channels != dec->channels)
514
        ost->audio_resample = 1;
515

    
516
    if (ost->audio_resample && !ost->resample) {
517
        ost->resample = audio_resample_init(enc->channels,    dec->channels,
518
                                            enc->sample_rate, dec->sample_rate);
519
        if (!ost->resample) {
520
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
521
                    dec->channels, dec->sample_rate,
522
                    enc->channels, enc->sample_rate);
523
            exit(1);
524
        }
525
    }
526

    
527
    if(audio_sync_method){
528
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
529
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
530
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
531
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
532

    
533
        //FIXME resample delay
534
        if(fabs(delta) > 50){
535
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
536
                if(byte_delta < 0){
537
                    byte_delta= FFMAX(byte_delta, -size);
538
                    size += byte_delta;
539
                    buf  -= byte_delta;
540
                    if(verbose > 2)
541
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
542
                    if(!size)
543
                        return;
544
                    ist->is_start=0;
545
                }else{
546
                    static uint8_t *input_tmp= NULL;
547
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
548

    
549
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
550
                        ist->is_start=0;
551
                    else
552
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
553

    
554
                    memset(input_tmp, 0, byte_delta);
555
                    memcpy(input_tmp + byte_delta, buf, size);
556
                    buf= input_tmp;
557
                    size += byte_delta;
558
                    if(verbose > 2)
559
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
560
                }
561
            }else if(audio_sync_method>1){
562
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
563
                assert(ost->audio_resample);
564
                if(verbose > 2)
565
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
566
//                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));
567
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
568
            }
569
        }
570
    }else
571
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
572
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
573

    
574
    if (ost->audio_resample) {
575
        buftmp = audio_buf;
576
        size_out = audio_resample(ost->resample,
577
                                  (short *)buftmp, (short *)buf,
578
                                  size / (ist->st->codec->channels * 2));
579
        size_out = size_out * enc->channels * 2;
580
    } else {
581
        buftmp = buf;
582
        size_out = size;
583
    }
584

    
585
    /* now encode as many frames as possible */
586
    if (enc->frame_size > 1) {
587
        /* output resampled raw samples */
588
        av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out + 1);
589
        av_fifo_write(&ost->fifo, buftmp, size_out);
590

    
591
        frame_bytes = enc->frame_size * 2 * enc->channels;
592

    
593
        while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
594
            AVPacket pkt;
595
            av_init_packet(&pkt);
596

    
597
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
598

    
599
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
600
                                       (short *)audio_buf);
601
            audio_size += ret;
602
            pkt.stream_index= ost->index;
603
            pkt.data= audio_out;
604
            pkt.size= ret;
605
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
606
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
607
            pkt.flags |= PKT_FLAG_KEY;
608
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
609

    
610
            ost->sync_opts += enc->frame_size;
611
        }
612
    } else {
613
        AVPacket pkt;
614
        av_init_packet(&pkt);
615

    
616
        ost->sync_opts += size_out / (2 * enc->channels);
617

    
618
        /* output a pcm frame */
619
        /* XXX: change encoding codec API to avoid this ? */
620
        switch(enc->codec->id) {
621
        case CODEC_ID_PCM_S32LE:
622
        case CODEC_ID_PCM_S32BE:
623
        case CODEC_ID_PCM_U32LE:
624
        case CODEC_ID_PCM_U32BE:
625
            size_out = size_out << 1;
626
            break;
627
        case CODEC_ID_PCM_S24LE:
628
        case CODEC_ID_PCM_S24BE:
629
        case CODEC_ID_PCM_U24LE:
630
        case CODEC_ID_PCM_U24BE:
631
        case CODEC_ID_PCM_S24DAUD:
632
            size_out = size_out / 2 * 3;
633
            break;
634
        case CODEC_ID_PCM_S16LE:
635
        case CODEC_ID_PCM_S16BE:
636
        case CODEC_ID_PCM_U16LE:
637
        case CODEC_ID_PCM_U16BE:
638
            break;
639
        default:
640
            size_out = size_out >> 1;
641
            break;
642
        }
643
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
644
        ret = avcodec_encode_audio(enc, audio_out, size_out,
645
                                   (short *)buftmp);
646
        audio_size += ret;
647
        pkt.stream_index= ost->index;
648
        pkt.data= audio_out;
649
        pkt.size= ret;
650
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
651
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
652
        pkt.flags |= PKT_FLAG_KEY;
653
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
654
    }
655
}
656

    
657
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
658
{
659
    AVCodecContext *dec;
660
    AVPicture *picture2;
661
    AVPicture picture_tmp;
662
    uint8_t *buf = 0;
663

    
664
    dec = ist->st->codec;
665

    
666
    /* deinterlace : must be done before any resize */
667
    if (do_deinterlace || using_vhook) {
668
        int size;
669

    
670
        /* create temporary picture */
671
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
672
        buf = av_malloc(size);
673
        if (!buf)
674
            return;
675

    
676
        picture2 = &picture_tmp;
677
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
678

    
679
        if (do_deinterlace){
680
            if(avpicture_deinterlace(picture2, picture,
681
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
682
                /* if error, do not deinterlace */
683
                av_free(buf);
684
                buf = NULL;
685
                picture2 = picture;
686
            }
687
        } else {
688
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
689
        }
690
    } else {
691
        picture2 = picture;
692
    }
693

    
694
    if (ENABLE_VHOOK)
695
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
696
                           1000000 * ist->pts / AV_TIME_BASE);
697

    
698
    if (picture != picture2)
699
        *picture = *picture2;
700
    *bufp = buf;
701
}
702

    
703
/* we begin to correct av delay at this threshold */
704
#define AV_DELAY_MAX 0.100
705

    
706
static void do_subtitle_out(AVFormatContext *s,
707
                            AVOutputStream *ost,
708
                            AVInputStream *ist,
709
                            AVSubtitle *sub,
710
                            int64_t pts)
711
{
712
    static uint8_t *subtitle_out = NULL;
713
    int subtitle_out_max_size = 65536;
714
    int subtitle_out_size, nb, i;
715
    AVCodecContext *enc;
716
    AVPacket pkt;
717

    
718
    if (pts == AV_NOPTS_VALUE) {
719
        fprintf(stderr, "Subtitle packets must have a pts\n");
720
        return;
721
    }
722

    
723
    enc = ost->st->codec;
724

    
725
    if (!subtitle_out) {
726
        subtitle_out = av_malloc(subtitle_out_max_size);
727
    }
728

    
729
    /* Note: DVB subtitle need one packet to draw them and one other
730
       packet to clear them */
731
    /* XXX: signal it in the codec context ? */
732
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
733
        nb = 2;
734
    else
735
        nb = 1;
736

    
737
    for(i = 0; i < nb; i++) {
738
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
739
                                                    subtitle_out_max_size, sub);
740

    
741
        av_init_packet(&pkt);
742
        pkt.stream_index = ost->index;
743
        pkt.data = subtitle_out;
744
        pkt.size = subtitle_out_size;
745
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
746
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
747
            /* XXX: the pts correction is handled here. Maybe handling
748
               it in the codec would be better */
749
            if (i == 0)
750
                pkt.pts += 90 * sub->start_display_time;
751
            else
752
                pkt.pts += 90 * sub->end_display_time;
753
        }
754
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
755
    }
756
}
757

    
758
static int bit_buffer_size= 1024*256;
759
static uint8_t *bit_buffer= NULL;
760

    
761
static void do_video_out(AVFormatContext *s,
762
                         AVOutputStream *ost,
763
                         AVInputStream *ist,
764
                         AVFrame *in_picture,
765
                         int *frame_size)
766
{
767
    int nb_frames, i, ret;
768
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
769
    AVFrame picture_crop_temp, picture_pad_temp;
770
    AVCodecContext *enc, *dec;
771

    
772
    avcodec_get_frame_defaults(&picture_crop_temp);
773
    avcodec_get_frame_defaults(&picture_pad_temp);
774

    
775
    enc = ost->st->codec;
776
    dec = ist->st->codec;
777

    
778
    /* by default, we output a single frame */
779
    nb_frames = 1;
780

    
781
    *frame_size = 0;
782

    
783
    if(video_sync_method){
784
        double vdelta;
785
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
786
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
787
        if (vdelta < -1.1)
788
            nb_frames = 0;
789
        else if (video_sync_method == 2)
790
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
791
        else if (vdelta > 1.1)
792
            nb_frames = lrintf(vdelta);
793
//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);
794
        if (nb_frames == 0){
795
            ++nb_frames_drop;
796
            if (verbose>2)
797
                fprintf(stderr, "*** drop!\n");
798
        }else if (nb_frames > 1) {
799
            nb_frames_dup += nb_frames;
800
            if (verbose>2)
801
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
802
        }
803
    }else
804
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
805

    
806
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
807
    if (nb_frames <= 0)
808
        return;
809

    
810
    if (ost->video_crop) {
811
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
812
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
813
            return;
814
        }
815
        formatted_picture = &picture_crop_temp;
816
    } else {
817
        formatted_picture = in_picture;
818
    }
819

    
820
    final_picture = formatted_picture;
821
    padding_src = formatted_picture;
822
    resampling_dst = &ost->pict_tmp;
823
    if (ost->video_pad) {
824
        final_picture = &ost->pict_tmp;
825
        if (ost->video_resample) {
826
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
827
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
828
                return;
829
            }
830
            resampling_dst = &picture_pad_temp;
831
        }
832
    }
833

    
834
    if (ost->video_resample) {
835
        padding_src = NULL;
836
        final_picture = &ost->pict_tmp;
837
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
838
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
839
    }
840

    
841
    if (ost->video_pad) {
842
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
843
                enc->height, enc->width, enc->pix_fmt,
844
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
845
    }
846

    
847
    /* duplicates frame if needed */
848
    for(i=0;i<nb_frames;i++) {
849
        AVPacket pkt;
850
        av_init_packet(&pkt);
851
        pkt.stream_index= ost->index;
852

    
853
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
854
            /* raw pictures are written as AVPicture structure to
855
               avoid any copies. We support temorarily the older
856
               method. */
857
            AVFrame* old_frame = enc->coded_frame;
858
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
859
            pkt.data= (uint8_t *)final_picture;
860
            pkt.size=  sizeof(AVPicture);
861
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
862
            pkt.flags |= PKT_FLAG_KEY;
863

    
864
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
865
            enc->coded_frame = old_frame;
866
        } else {
867
            AVFrame big_picture;
868

    
869
            big_picture= *final_picture;
870
            /* better than nothing: use input picture interlaced
871
               settings */
872
            big_picture.interlaced_frame = in_picture->interlaced_frame;
873
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
874
                if(top_field_first == -1)
875
                    big_picture.top_field_first = in_picture->top_field_first;
876
                else
877
                    big_picture.top_field_first = top_field_first;
878
            }
879

    
880
            /* handles sameq here. This is not correct because it may
881
               not be a global option */
882
            if (same_quality) {
883
                big_picture.quality = ist->st->quality;
884
            }else
885
                big_picture.quality = ost->st->quality;
886
            if(!me_threshold)
887
                big_picture.pict_type = 0;
888
//            big_picture.pts = AV_NOPTS_VALUE;
889
            big_picture.pts= ost->sync_opts;
890
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
891
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
892
            ret = avcodec_encode_video(enc,
893
                                       bit_buffer, bit_buffer_size,
894
                                       &big_picture);
895
            if (ret == -1) {
896
                fprintf(stderr, "Video encoding failed\n");
897
                exit(1);
898
            }
899
            //enc->frame_number = enc->real_pict_num;
900
            if(ret>0){
901
                pkt.data= bit_buffer;
902
                pkt.size= ret;
903
                if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
904
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
905
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
906
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
907
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
908

    
909
                if(enc->coded_frame && enc->coded_frame->key_frame)
910
                    pkt.flags |= PKT_FLAG_KEY;
911
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
912
                *frame_size = ret;
913
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
914
                //        enc->frame_number-1, enc->real_pict_num, ret,
915
                //        enc->pict_type);
916
                /* if two pass, output log */
917
                if (ost->logfile && enc->stats_out) {
918
                    fprintf(ost->logfile, "%s", enc->stats_out);
919
                }
920
            }
921
        }
922
        ost->sync_opts++;
923
        ost->frame_number++;
924
    }
925
}
926

    
927
static double psnr(double d){
928
    return -10.0*log(d)/log(10.0);
929
}
930

    
931
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
932
                           int frame_size)
933
{
934
    AVCodecContext *enc;
935
    int frame_number;
936
    double ti1, bitrate, avg_bitrate;
937

    
938
    /* this is executed just the first time do_video_stats is called */
939
    if (!vstats_file) {
940
        vstats_file = fopen(vstats_filename, "w");
941
        if (!vstats_file) {
942
            perror("fopen");
943
            exit(1);
944
        }
945
    }
946

    
947
    enc = ost->st->codec;
948
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
949
        frame_number = ost->frame_number;
950
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
951
        if (enc->flags&CODEC_FLAG_PSNR)
952
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
953

    
954
        fprintf(vstats_file,"f_size= %6d ", frame_size);
955
        /* compute pts value */
956
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
957
        if (ti1 < 0.01)
958
            ti1 = 0.01;
959

    
960
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
961
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
962
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
963
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
964
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
965
    }
966
}
967

    
968
static void print_report(AVFormatContext **output_files,
969
                         AVOutputStream **ost_table, int nb_ostreams,
970
                         int is_last_report)
971
{
972
    char buf[1024];
973
    AVOutputStream *ost;
974
    AVFormatContext *oc, *os;
975
    int64_t total_size;
976
    AVCodecContext *enc;
977
    int frame_number, vid, i;
978
    double bitrate, ti1, pts;
979
    static int64_t last_time = -1;
980
    static int qp_histogram[52];
981

    
982
    if (!is_last_report) {
983
        int64_t cur_time;
984
        /* display the report every 0.5 seconds */
985
        cur_time = av_gettime();
986
        if (last_time == -1) {
987
            last_time = cur_time;
988
            return;
989
        }
990
        if ((cur_time - last_time) < 500000)
991
            return;
992
        last_time = cur_time;
993
    }
994

    
995

    
996
    oc = output_files[0];
997

    
998
    total_size = url_fsize(oc->pb);
999
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1000
        total_size= url_ftell(oc->pb);
1001

    
1002
    buf[0] = '\0';
1003
    ti1 = 1e10;
1004
    vid = 0;
1005
    for(i=0;i<nb_ostreams;i++) {
1006
        ost = ost_table[i];
1007
        os = output_files[ost->file_index];
1008
        enc = ost->st->codec;
1009
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1010
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1011
                     enc->coded_frame && !ost->st->stream_copy ?
1012
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1013
        }
1014
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1015
            float t = (av_gettime()-timer_start) / 1000000.0;
1016

    
1017
            frame_number = ost->frame_number;
1018
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1019
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1020
                     enc->coded_frame && !ost->st->stream_copy ?
1021
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1022
            if(is_last_report)
1023
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1024
            if(qp_hist && enc->coded_frame){
1025
                int j;
1026
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1027
                if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1028
                    qp_histogram[qp]++;
1029
                for(j=0; j<32; j++)
1030
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1031
            }
1032
            if (enc->flags&CODEC_FLAG_PSNR){
1033
                int j;
1034
                double error, error_sum=0;
1035
                double scale, scale_sum=0;
1036
                char type[3]= {'Y','U','V'};
1037
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1038
                for(j=0; j<3; j++){
1039
                    if(is_last_report){
1040
                        error= enc->error[j];
1041
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1042
                    }else{
1043
                        error= enc->coded_frame->error[j];
1044
                        scale= enc->width*enc->height*255.0*255.0;
1045
                    }
1046
                    if(j) scale/=4;
1047
                    error_sum += error;
1048
                    scale_sum += scale;
1049
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1050
                }
1051
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1052
            }
1053
            vid = 1;
1054
        }
1055
        /* compute min output value */
1056
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1057
        if ((pts < ti1) && (pts > 0))
1058
            ti1 = pts;
1059
    }
1060
    if (ti1 < 0.01)
1061
        ti1 = 0.01;
1062

    
1063
    if (verbose || is_last_report) {
1064
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1065

    
1066
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1067
            "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1068
            (double)total_size / 1024, ti1, bitrate);
1069

    
1070
        if (verbose > 1)
1071
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1072
                  nb_frames_dup, nb_frames_drop);
1073

    
1074
        if (verbose >= 0)
1075
            fprintf(stderr, "%s    \r", buf);
1076

    
1077
        fflush(stderr);
1078
    }
1079

    
1080
    if (is_last_report && verbose >= 0){
1081
        int64_t raw= audio_size + video_size + extra_size;
1082
        fprintf(stderr, "\n");
1083
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1084
                video_size/1024.0,
1085
                audio_size/1024.0,
1086
                extra_size/1024.0,
1087
                100.0*(total_size - raw)/raw
1088
        );
1089
    }
1090
}
1091

    
1092
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1093
static int output_packet(AVInputStream *ist, int ist_index,
1094
                         AVOutputStream **ost_table, int nb_ostreams,
1095
                         const AVPacket *pkt)
1096
{
1097
    AVFormatContext *os;
1098
    AVOutputStream *ost;
1099
    uint8_t *ptr;
1100
    int len, ret, i;
1101
    uint8_t *data_buf;
1102
    int data_size, got_picture;
1103
    AVFrame picture;
1104
    void *buffer_to_free;
1105
    static unsigned int samples_size= 0;
1106
    static short *samples= NULL;
1107
    AVSubtitle subtitle, *subtitle_to_free;
1108
    int got_subtitle;
1109

    
1110
    if(ist->next_pts == AV_NOPTS_VALUE)
1111
        ist->next_pts= ist->pts;
1112

    
1113
    if (pkt == NULL) {
1114
        /* EOF handling */
1115
        ptr = NULL;
1116
        len = 0;
1117
        goto handle_eof;
1118
    }
1119

    
1120
    if(pkt->dts != AV_NOPTS_VALUE)
1121
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1122

    
1123
    len = pkt->size;
1124
    ptr = pkt->data;
1125
    while (len > 0) {
1126
    handle_eof:
1127
        ist->pts= ist->next_pts;
1128

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

    
1132
        /* decode the packet if needed */
1133
        data_buf = NULL; /* fail safe */
1134
        data_size = 0;
1135
        subtitle_to_free = NULL;
1136
        if (ist->decoding_needed) {
1137
            switch(ist->st->codec->codec_type) {
1138
            case CODEC_TYPE_AUDIO:{
1139
                if(pkt)
1140
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1141
                data_size= samples_size;
1142
                    /* XXX: could avoid copy if PCM 16 bits with same
1143
                       endianness as CPU */
1144
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1145
                                           ptr, len);
1146
                if (ret < 0)
1147
                    goto fail_decode;
1148
                ptr += ret;
1149
                len -= ret;
1150
                /* Some bug in mpeg audio decoder gives */
1151
                /* data_size < 0, it seems they are overflows */
1152
                if (data_size <= 0) {
1153
                    /* no audio frame */
1154
                    continue;
1155
                }
1156
                data_buf = (uint8_t *)samples;
1157
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1158
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1159
                break;}
1160
            case CODEC_TYPE_VIDEO:
1161
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1162
                    /* XXX: allocate picture correctly */
1163
                    avcodec_get_frame_defaults(&picture);
1164

    
1165
                    ret = avcodec_decode_video(ist->st->codec,
1166
                                               &picture, &got_picture, ptr, len);
1167
                    ist->st->quality= picture.quality;
1168
                    if (ret < 0)
1169
                        goto fail_decode;
1170
                    if (!got_picture) {
1171
                        /* no picture yet */
1172
                        goto discard_packet;
1173
                    }
1174
                    if (ist->st->codec->time_base.num != 0) {
1175
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1176
                                          ist->st->codec->time_base.num) /
1177
                            ist->st->codec->time_base.den;
1178
                    }
1179
                    len = 0;
1180
                    break;
1181
            case CODEC_TYPE_SUBTITLE:
1182
                ret = avcodec_decode_subtitle(ist->st->codec,
1183
                                              &subtitle, &got_subtitle, ptr, len);
1184
                if (ret < 0)
1185
                    goto fail_decode;
1186
                if (!got_subtitle) {
1187
                    goto discard_packet;
1188
                }
1189
                subtitle_to_free = &subtitle;
1190
                len = 0;
1191
                break;
1192
            default:
1193
                goto fail_decode;
1194
            }
1195
        } else {
1196
            switch(ist->st->codec->codec_type) {
1197
            case CODEC_TYPE_AUDIO:
1198
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1199
                    ist->st->codec->sample_rate;
1200
                break;
1201
            case CODEC_TYPE_VIDEO:
1202
                if (ist->st->codec->time_base.num != 0) {
1203
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1204
                                      ist->st->codec->time_base.num) /
1205
                        ist->st->codec->time_base.den;
1206
                }
1207
                break;
1208
            }
1209
            data_buf = ptr;
1210
            data_size = len;
1211
            ret = len;
1212
            len = 0;
1213
        }
1214

    
1215
        buffer_to_free = NULL;
1216
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1217
            pre_process_video_frame(ist, (AVPicture *)&picture,
1218
                                    &buffer_to_free);
1219
        }
1220

    
1221
        // preprocess audio (volume)
1222
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1223
            if (audio_volume != 256) {
1224
                short *volp;
1225
                volp = samples;
1226
                for(i=0;i<(data_size / sizeof(short));i++) {
1227
                    int v = ((*volp) * audio_volume + 128) >> 8;
1228
                    if (v < -32768) v = -32768;
1229
                    if (v >  32767) v = 32767;
1230
                    *volp++ = v;
1231
                }
1232
            }
1233
        }
1234

    
1235
        /* frame rate emulation */
1236
        if (ist->st->codec->rate_emu) {
1237
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1238
            int64_t now = av_gettime() - ist->start;
1239
            if (pts > now)
1240
                usleep(pts - now);
1241

    
1242
            ist->frame++;
1243
        }
1244

    
1245
#if 0
1246
        /* mpeg PTS deordering : if it is a P or I frame, the PTS
1247
           is the one of the next displayed one */
1248
        /* XXX: add mpeg4 too ? */
1249
        if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1250
            if (ist->st->codec->pict_type != B_TYPE) {
1251
                int64_t tmp;
1252
                tmp = ist->last_ip_pts;
1253
                ist->last_ip_pts  = ist->frac_pts.val;
1254
                ist->frac_pts.val = tmp;
1255
            }
1256
        }
1257
#endif
1258
        /* if output time reached then transcode raw format,
1259
           encode packets and output them */
1260
        if (start_time == 0 || ist->pts >= start_time)
1261
            for(i=0;i<nb_ostreams;i++) {
1262
                int frame_size;
1263

    
1264
                ost = ost_table[i];
1265
                if (ost->source_index == ist_index) {
1266
                    os = output_files[ost->file_index];
1267

    
1268
#if 0
1269
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1270
                           (double)pkt->pts / AV_TIME_BASE,
1271
                           ((double)ist->pts / AV_TIME_BASE) -
1272
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1273
#endif
1274
                    /* set the input output pts pairs */
1275
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1276

    
1277
                    if (ost->encoding_needed) {
1278
                        switch(ost->st->codec->codec_type) {
1279
                        case CODEC_TYPE_AUDIO:
1280
                            do_audio_out(os, ost, ist, data_buf, data_size);
1281
                            break;
1282
                        case CODEC_TYPE_VIDEO:
1283
                            do_video_out(os, ost, ist, &picture, &frame_size);
1284
                            video_size += frame_size;
1285
                            if (vstats_filename && frame_size)
1286
                                do_video_stats(os, ost, frame_size);
1287
                            break;
1288
                        case CODEC_TYPE_SUBTITLE:
1289
                            do_subtitle_out(os, ost, ist, &subtitle,
1290
                                            pkt->pts);
1291
                            break;
1292
                        default:
1293
                            abort();
1294
                        }
1295
                    } else {
1296
                        AVFrame avframe; //FIXME/XXX remove this
1297
                        AVPacket opkt;
1298
                        av_init_packet(&opkt);
1299

    
1300
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1301
                            continue;
1302

    
1303
                        /* no reencoding needed : output the packet directly */
1304
                        /* force the input stream PTS */
1305

    
1306
                        avcodec_get_frame_defaults(&avframe);
1307
                        ost->st->codec->coded_frame= &avframe;
1308
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1309

    
1310
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1311
                            audio_size += data_size;
1312
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1313
                            video_size += data_size;
1314
                            ost->sync_opts++;
1315
                        }
1316

    
1317
                        opkt.stream_index= ost->index;
1318
                        if(pkt->pts != AV_NOPTS_VALUE)
1319
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1320
                        else
1321
                            opkt.pts= AV_NOPTS_VALUE;
1322

    
1323
                            if (pkt->dts == AV_NOPTS_VALUE)
1324
                                opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1325
                            else
1326
                                opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1327

    
1328
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1329
                        opkt.flags= pkt->flags;
1330

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

    
1335
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1336
                        ost->st->codec->frame_number++;
1337
                        ost->frame_number++;
1338
                        av_free_packet(&opkt);
1339
                    }
1340
                }
1341
            }
1342
        av_free(buffer_to_free);
1343
        /* XXX: allocate the subtitles in the codec ? */
1344
        if (subtitle_to_free) {
1345
            if (subtitle_to_free->rects != NULL) {
1346
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1347
                    av_free(subtitle_to_free->rects[i].bitmap);
1348
                    av_free(subtitle_to_free->rects[i].rgba_palette);
1349
                }
1350
                av_freep(&subtitle_to_free->rects);
1351
            }
1352
            subtitle_to_free->num_rects = 0;
1353
            subtitle_to_free = NULL;
1354
        }
1355
    }
1356
 discard_packet:
1357
    if (pkt == NULL) {
1358
        /* EOF handling */
1359

    
1360
        for(i=0;i<nb_ostreams;i++) {
1361
            ost = ost_table[i];
1362
            if (ost->source_index == ist_index) {
1363
                AVCodecContext *enc= ost->st->codec;
1364
                os = output_files[ost->file_index];
1365

    
1366
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1367
                    continue;
1368
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1369
                    continue;
1370

    
1371
                if (ost->encoding_needed) {
1372
                    for(;;) {
1373
                        AVPacket pkt;
1374
                        int fifo_bytes;
1375
                        av_init_packet(&pkt);
1376
                        pkt.stream_index= ost->index;
1377

    
1378
                        switch(ost->st->codec->codec_type) {
1379
                        case CODEC_TYPE_AUDIO:
1380
                            fifo_bytes = av_fifo_size(&ost->fifo);
1381
                            ret = 0;
1382
                            /* encode any samples remaining in fifo */
1383
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1384
                                int fs_tmp = enc->frame_size;
1385
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1386
                                if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1387
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1388
                                }
1389
                                enc->frame_size = fs_tmp;
1390
                            }
1391
                            if(ret <= 0) {
1392
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1393
                            }
1394
                            audio_size += ret;
1395
                            pkt.flags |= PKT_FLAG_KEY;
1396
                            break;
1397
                        case CODEC_TYPE_VIDEO:
1398
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1399
                            video_size += ret;
1400
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1401
                                pkt.flags |= PKT_FLAG_KEY;
1402
                            if (ost->logfile && enc->stats_out) {
1403
                                fprintf(ost->logfile, "%s", enc->stats_out);
1404
                            }
1405
                            break;
1406
                        default:
1407
                            ret=-1;
1408
                        }
1409

    
1410
                        if(ret<=0)
1411
                            break;
1412
                        pkt.data= bit_buffer;
1413
                        pkt.size= ret;
1414
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1415
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1416
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1417
                    }
1418
                }
1419
            }
1420
        }
1421
    }
1422

    
1423
    return 0;
1424
 fail_decode:
1425
    return -1;
1426
}
1427

    
1428
static void print_sdp(AVFormatContext **avc, int n)
1429
{
1430
    char sdp[2048];
1431

    
1432
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1433
    printf("SDP:\n%s\n", sdp);
1434
}
1435

    
1436
static int stream_index_from_inputs(AVFormatContext **input_files,
1437
                                    int nb_input_files,
1438
                                    AVInputFile *file_table,
1439
                                    AVInputStream **ist_table,
1440
                                    enum CodecType type,
1441
                                    int programid)
1442
{
1443
    int p, q, z;
1444
    for(z=0; z<nb_input_files; z++) {
1445
        AVFormatContext *ic = input_files[z];
1446
        for(p=0; p<ic->nb_programs; p++) {
1447
            AVProgram *program = ic->programs[p];
1448
            if(program->id != programid)
1449
                continue;
1450
            for(q=0; q<program->nb_stream_indexes; q++) {
1451
                int sidx = program->stream_index[q];
1452
                int ris = file_table[z].ist_index + sidx;
1453
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1454
                    return ris;
1455
            }
1456
        }
1457
    }
1458

    
1459
    return -1;
1460
}
1461

    
1462
/*
1463
 * The following code is the main loop of the file converter
1464
 */
1465
static int av_encode(AVFormatContext **output_files,
1466
                     int nb_output_files,
1467
                     AVFormatContext **input_files,
1468
                     int nb_input_files,
1469
                     AVStreamMap *stream_maps, int nb_stream_maps)
1470
{
1471
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1472
    AVFormatContext *is, *os;
1473
    AVCodecContext *codec, *icodec;
1474
    AVOutputStream *ost, **ost_table = NULL;
1475
    AVInputStream *ist, **ist_table = NULL;
1476
    AVInputFile *file_table;
1477
    int key;
1478
    int want_sdp = 1;
1479

    
1480
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1481
    if (!file_table)
1482
        goto fail;
1483

    
1484
    /* input stream init */
1485
    j = 0;
1486
    for(i=0;i<nb_input_files;i++) {
1487
        is = input_files[i];
1488
        file_table[i].ist_index = j;
1489
        file_table[i].nb_streams = is->nb_streams;
1490
        j += is->nb_streams;
1491
    }
1492
    nb_istreams = j;
1493

    
1494
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1495
    if (!ist_table)
1496
        goto fail;
1497

    
1498
    for(i=0;i<nb_istreams;i++) {
1499
        ist = av_mallocz(sizeof(AVInputStream));
1500
        if (!ist)
1501
            goto fail;
1502
        ist_table[i] = ist;
1503
    }
1504
    j = 0;
1505
    for(i=0;i<nb_input_files;i++) {
1506
        is = input_files[i];
1507
        for(k=0;k<is->nb_streams;k++) {
1508
            ist = ist_table[j++];
1509
            ist->st = is->streams[k];
1510
            ist->file_index = i;
1511
            ist->index = k;
1512
            ist->discard = 1; /* the stream is discarded by default
1513
                                 (changed later) */
1514

    
1515
            if (ist->st->codec->rate_emu) {
1516
                ist->start = av_gettime();
1517
                ist->frame = 0;
1518
            }
1519
        }
1520
    }
1521

    
1522
    /* output stream init */
1523
    nb_ostreams = 0;
1524
    for(i=0;i<nb_output_files;i++) {
1525
        os = output_files[i];
1526
        if (!os->nb_streams) {
1527
            fprintf(stderr, "Output file does not contain any stream\n");
1528
            exit(1);
1529
        }
1530
        nb_ostreams += os->nb_streams;
1531
    }
1532
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1533
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1534
        exit(1);
1535
    }
1536

    
1537
    /* Sanity check the mapping args -- do the input files & streams exist? */
1538
    for(i=0;i<nb_stream_maps;i++) {
1539
        int fi = stream_maps[i].file_index;
1540
        int si = stream_maps[i].stream_index;
1541

    
1542
        if (fi < 0 || fi > nb_input_files - 1 ||
1543
            si < 0 || si > file_table[fi].nb_streams - 1) {
1544
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1545
            exit(1);
1546
        }
1547
        fi = stream_maps[i].sync_file_index;
1548
        si = stream_maps[i].sync_stream_index;
1549
        if (fi < 0 || fi > nb_input_files - 1 ||
1550
            si < 0 || si > file_table[fi].nb_streams - 1) {
1551
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1552
            exit(1);
1553
        }
1554
    }
1555

    
1556
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1557
    if (!ost_table)
1558
        goto fail;
1559
    for(i=0;i<nb_ostreams;i++) {
1560
        ost = av_mallocz(sizeof(AVOutputStream));
1561
        if (!ost)
1562
            goto fail;
1563
        ost_table[i] = ost;
1564
    }
1565

    
1566
    n = 0;
1567
    for(k=0;k<nb_output_files;k++) {
1568
        os = output_files[k];
1569
        for(i=0;i<os->nb_streams;i++) {
1570
            int found;
1571
            ost = ost_table[n++];
1572
            ost->file_index = k;
1573
            ost->index = i;
1574
            ost->st = os->streams[i];
1575
            if (nb_stream_maps > 0) {
1576
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1577
                    stream_maps[n-1].stream_index;
1578

    
1579
                /* Sanity check that the stream types match */
1580
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1581
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1582
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1583
                        ost->file_index, ost->index);
1584
                    exit(1);
1585
                }
1586

    
1587
            } else {
1588
                if(opt_programid) {
1589
                    found = 0;
1590
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1591
                    if(j != -1) {
1592
                        ost->source_index = j;
1593
                        found = 1;
1594
                    }
1595
                } else {
1596
                    /* get corresponding input stream index : we select the first one with the right type */
1597
                    found = 0;
1598
                    for(j=0;j<nb_istreams;j++) {
1599
                        ist = ist_table[j];
1600
                        if (ist->discard &&
1601
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1602
                            ost->source_index = j;
1603
                            found = 1;
1604
                            break;
1605
                        }
1606
                    }
1607
                }
1608

    
1609
                if (!found) {
1610
                    if(! opt_programid) {
1611
                        /* try again and reuse existing stream */
1612
                        for(j=0;j<nb_istreams;j++) {
1613
                            ist = ist_table[j];
1614
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1615
                                ost->source_index = j;
1616
                                found = 1;
1617
                            }
1618
                        }
1619
                    }
1620
                    if (!found) {
1621
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1622
                                ost->file_index, ost->index);
1623
                        exit(1);
1624
                    }
1625
                }
1626
            }
1627
            ist = ist_table[ost->source_index];
1628
            ist->discard = 0;
1629
            ost->sync_ist = (nb_stream_maps > 0) ?
1630
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1631
                         stream_maps[n-1].sync_stream_index] : ist;
1632
        }
1633
    }
1634

    
1635
    /* for each output stream, we compute the right encoding parameters */
1636
    for(i=0;i<nb_ostreams;i++) {
1637
        ost = ost_table[i];
1638
        os = output_files[ost->file_index];
1639
        ist = ist_table[ost->source_index];
1640

    
1641
        codec = ost->st->codec;
1642
        icodec = ist->st->codec;
1643

    
1644
        if (!ost->st->language[0])
1645
            av_strlcpy(ost->st->language, ist->st->language,
1646
                       sizeof(ost->st->language));
1647

    
1648
        ost->st->disposition = ist->st->disposition;
1649

    
1650
        if (ost->st->stream_copy) {
1651
            /* if stream_copy is selected, no need to decode or encode */
1652
            codec->codec_id = icodec->codec_id;
1653
            codec->codec_type = icodec->codec_type;
1654

    
1655
            if(!codec->codec_tag){
1656
                if(   !os->oformat->codec_tag
1657
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1658
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1659
                    codec->codec_tag = icodec->codec_tag;
1660
            }
1661

    
1662
            codec->bit_rate = icodec->bit_rate;
1663
            codec->extradata= icodec->extradata;
1664
            codec->extradata_size= icodec->extradata_size;
1665
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1666
                codec->time_base = icodec->time_base;
1667
            else
1668
                codec->time_base = ist->st->time_base;
1669
            switch(codec->codec_type) {
1670
            case CODEC_TYPE_AUDIO:
1671
                codec->sample_rate = icodec->sample_rate;
1672
                codec->channels = icodec->channels;
1673
                codec->frame_size = icodec->frame_size;
1674
                codec->block_align= icodec->block_align;
1675
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1676
                    codec->block_align= 0;
1677
                break;
1678
            case CODEC_TYPE_VIDEO:
1679
                if(using_vhook) {
1680
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1681
                    exit(1);
1682
                }
1683
                codec->pix_fmt = icodec->pix_fmt;
1684
                codec->width = icodec->width;
1685
                codec->height = icodec->height;
1686
                codec->has_b_frames = icodec->has_b_frames;
1687
                break;
1688
            case CODEC_TYPE_SUBTITLE:
1689
                break;
1690
            default:
1691
                abort();
1692
            }
1693
        } else {
1694
            switch(codec->codec_type) {
1695
            case CODEC_TYPE_AUDIO:
1696
                if (av_fifo_init(&ost->fifo, 1024))
1697
                    goto fail;
1698
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1699
                icodec->request_channels = codec->channels;
1700
                ist->decoding_needed = 1;
1701
                ost->encoding_needed = 1;
1702
                break;
1703
            case CODEC_TYPE_VIDEO:
1704
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1705
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1706
                ost->video_resample = ((codec->width != icodec->width -
1707
                                (frame_leftBand + frame_rightBand) +
1708
                                (frame_padleft + frame_padright)) ||
1709
                        (codec->height != icodec->height -
1710
                                (frame_topBand  + frame_bottomBand) +
1711
                                (frame_padtop + frame_padbottom)) ||
1712
                        (codec->pix_fmt != icodec->pix_fmt));
1713
                if (ost->video_crop) {
1714
                    ost->topBand = frame_topBand;
1715
                    ost->leftBand = frame_leftBand;
1716
                }
1717
                if (ost->video_pad) {
1718
                    ost->padtop = frame_padtop;
1719
                    ost->padleft = frame_padleft;
1720
                    ost->padbottom = frame_padbottom;
1721
                    ost->padright = frame_padright;
1722
                    if (!ost->video_resample) {
1723
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1724
                        if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1725
                                         codec->width, codec->height ) )
1726
                            goto fail;
1727
                    }
1728
                }
1729
                if (ost->video_resample) {
1730
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1731
                    if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1732
                                         codec->width, codec->height ) ) {
1733
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1734
                        exit(1);
1735
                    }
1736
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1737
                    ost->img_resample_ctx = sws_getContext(
1738
                            icodec->width - (frame_leftBand + frame_rightBand),
1739
                            icodec->height - (frame_topBand + frame_bottomBand),
1740
                            icodec->pix_fmt,
1741
                            codec->width - (frame_padleft + frame_padright),
1742
                            codec->height - (frame_padtop + frame_padbottom),
1743
                            codec->pix_fmt,
1744
                            sws_flags, NULL, NULL, NULL);
1745
                    if (ost->img_resample_ctx == NULL) {
1746
                        fprintf(stderr, "Cannot get resampling context\n");
1747
                        exit(1);
1748
                    }
1749
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1750
                }
1751
                ost->encoding_needed = 1;
1752
                ist->decoding_needed = 1;
1753
                break;
1754
            case CODEC_TYPE_SUBTITLE:
1755
                ost->encoding_needed = 1;
1756
                ist->decoding_needed = 1;
1757
                break;
1758
            default:
1759
                abort();
1760
                break;
1761
            }
1762
            /* two pass mode */
1763
            if (ost->encoding_needed &&
1764
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1765
                char logfilename[1024];
1766
                FILE *f;
1767
                int size;
1768
                char *logbuffer;
1769

    
1770
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1771
                         pass_logfilename ?
1772
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1773
                if (codec->flags & CODEC_FLAG_PASS1) {
1774
                    f = fopen(logfilename, "w");
1775
                    if (!f) {
1776
                        perror(logfilename);
1777
                        exit(1);
1778
                    }
1779
                    ost->logfile = f;
1780
                } else {
1781
                    /* read the log file */
1782
                    f = fopen(logfilename, "r");
1783
                    if (!f) {
1784
                        perror(logfilename);
1785
                        exit(1);
1786
                    }
1787
                    fseek(f, 0, SEEK_END);
1788
                    size = ftell(f);
1789
                    fseek(f, 0, SEEK_SET);
1790
                    logbuffer = av_malloc(size + 1);
1791
                    if (!logbuffer) {
1792
                        fprintf(stderr, "Could not allocate log buffer\n");
1793
                        exit(1);
1794
                    }
1795
                    size = fread(logbuffer, 1, size, f);
1796
                    fclose(f);
1797
                    logbuffer[size] = '\0';
1798
                    codec->stats_in = logbuffer;
1799
                }
1800
            }
1801
        }
1802
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1803
            int size= codec->width * codec->height;
1804
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1805
        }
1806
    }
1807

    
1808
    if (!bit_buffer)
1809
        bit_buffer = av_malloc(bit_buffer_size);
1810
    if (!bit_buffer)
1811
        goto fail;
1812

    
1813
    /* dump the file output parameters - cannot be done before in case
1814
       of stream copy */
1815
    for(i=0;i<nb_output_files;i++) {
1816
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1817
    }
1818

    
1819
    /* dump the stream mapping */
1820
    if (verbose >= 0) {
1821
        fprintf(stderr, "Stream mapping:\n");
1822
        for(i=0;i<nb_ostreams;i++) {
1823
            ost = ost_table[i];
1824
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1825
                    ist_table[ost->source_index]->file_index,
1826
                    ist_table[ost->source_index]->index,
1827
                    ost->file_index,
1828
                    ost->index);
1829
            if (ost->sync_ist != ist_table[ost->source_index])
1830
                fprintf(stderr, " [sync #%d.%d]",
1831
                        ost->sync_ist->file_index,
1832
                        ost->sync_ist->index);
1833
            fprintf(stderr, "\n");
1834
        }
1835
    }
1836

    
1837
    /* open each encoder */
1838
    for(i=0;i<nb_ostreams;i++) {
1839
        ost = ost_table[i];
1840
        if (ost->encoding_needed) {
1841
            AVCodec *codec;
1842
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1843
            if (!codec) {
1844
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1845
                        ost->file_index, ost->index);
1846
                exit(1);
1847
            }
1848
            if (avcodec_open(ost->st->codec, codec) < 0) {
1849
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1850
                        ost->file_index, ost->index);
1851
                exit(1);
1852
            }
1853
            extra_size += ost->st->codec->extradata_size;
1854
        }
1855
    }
1856

    
1857
    /* open each decoder */
1858
    for(i=0;i<nb_istreams;i++) {
1859
        ist = ist_table[i];
1860
        if (ist->decoding_needed) {
1861
            AVCodec *codec;
1862
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1863
            if (!codec) {
1864
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1865
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1866
                exit(1);
1867
            }
1868
            if (avcodec_open(ist->st->codec, codec) < 0) {
1869
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1870
                        ist->file_index, ist->index);
1871
                exit(1);
1872
            }
1873
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1874
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1875
        }
1876
    }
1877

    
1878
    /* init pts */
1879
    for(i=0;i<nb_istreams;i++) {
1880
        ist = ist_table[i];
1881
        is = input_files[ist->file_index];
1882
        ist->pts = 0;
1883
        ist->next_pts = AV_NOPTS_VALUE;
1884
        ist->is_start = 1;
1885
    }
1886

    
1887
    /* set meta data information from input file if required */
1888
    for (i=0;i<nb_meta_data_maps;i++) {
1889
        AVFormatContext *out_file;
1890
        AVFormatContext *in_file;
1891

    
1892
        int out_file_index = meta_data_maps[i].out_file;
1893
        int in_file_index = meta_data_maps[i].in_file;
1894
        if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1895
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1896
            ret = AVERROR(EINVAL);
1897
            goto fail;
1898
        }
1899
        if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1900
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1901
            ret = AVERROR(EINVAL);
1902
            goto fail;
1903
        }
1904

    
1905
        out_file = output_files[out_file_index];
1906
        in_file = input_files[in_file_index];
1907

    
1908
        strcpy(out_file->title, in_file->title);
1909
        strcpy(out_file->author, in_file->author);
1910
        strcpy(out_file->copyright, in_file->copyright);
1911
        strcpy(out_file->comment, in_file->comment);
1912
        strcpy(out_file->album, in_file->album);
1913
        out_file->year = in_file->year;
1914
        out_file->track = in_file->track;
1915
        strcpy(out_file->genre, in_file->genre);
1916
    }
1917

    
1918
    /* open files and write file headers */
1919
    for(i=0;i<nb_output_files;i++) {
1920
        os = output_files[i];
1921
        if (av_write_header(os) < 0) {
1922
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1923
            ret = AVERROR(EINVAL);
1924
            goto fail;
1925
        }
1926
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
1927
            want_sdp = 0;
1928
        }
1929
    }
1930
    if (want_sdp) {
1931
        print_sdp(output_files, nb_output_files);
1932
    }
1933

    
1934
    if ( !using_stdin && verbose >= 0) {
1935
        fprintf(stderr, "Press [q] to stop encoding\n");
1936
        url_set_interrupt_cb(decode_interrupt_cb);
1937
    }
1938
    term_init();
1939

    
1940
    key = -1;
1941
    timer_start = av_gettime();
1942

    
1943
    for(; received_sigterm == 0;) {
1944
        int file_index, ist_index;
1945
        AVPacket pkt;
1946
        double ipts_min;
1947
        double opts_min;
1948

    
1949
    redo:
1950
        ipts_min= 1e100;
1951
        opts_min= 1e100;
1952
        /* if 'q' pressed, exits */
1953
        if (!using_stdin) {
1954
            if (q_pressed)
1955
                break;
1956
            /* read_key() returns 0 on EOF */
1957
            key = read_key();
1958
            if (key == 'q')
1959
                break;
1960
        }
1961

    
1962
        /* select the stream that we must read now by looking at the
1963
           smallest output pts */
1964
        file_index = -1;
1965
        for(i=0;i<nb_ostreams;i++) {
1966
            double ipts, opts;
1967
            ost = ost_table[i];
1968
            os = output_files[ost->file_index];
1969
            ist = ist_table[ost->source_index];
1970
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1971
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1972
            else
1973
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1974
            ipts = (double)ist->pts;
1975
            if (!file_table[ist->file_index].eof_reached){
1976
                if(ipts < ipts_min) {
1977
                    ipts_min = ipts;
1978
                    if(input_sync ) file_index = ist->file_index;
1979
                }
1980
                if(opts < opts_min) {
1981
                    opts_min = opts;
1982
                    if(!input_sync) file_index = ist->file_index;
1983
                }
1984
            }
1985
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1986
                file_index= -1;
1987
                break;
1988
            }
1989
        }
1990
        /* if none, if is finished */
1991
        if (file_index < 0) {
1992
            break;
1993
        }
1994

    
1995
        /* finish if recording time exhausted */
1996
        if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1997
            break;
1998

    
1999
        /* finish if limit size exhausted */
2000
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2001
            break;
2002

    
2003
        /* read a frame from it and output it in the fifo */
2004
        is = input_files[file_index];
2005
        if (av_read_frame(is, &pkt) < 0) {
2006
            file_table[file_index].eof_reached = 1;
2007
            if (opt_shortest)
2008
                break;
2009
            else
2010
                continue;
2011
        }
2012

    
2013
        if (do_pkt_dump) {
2014
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2015
        }
2016
        /* the following test is needed in case new streams appear
2017
           dynamically in stream : we ignore them */
2018
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2019
            goto discard_packet;
2020
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2021
        ist = ist_table[ist_index];
2022
        if (ist->discard)
2023
            goto discard_packet;
2024

    
2025
        if (pkt.dts != AV_NOPTS_VALUE)
2026
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2027
        if (pkt.pts != AV_NOPTS_VALUE)
2028
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2029

    
2030
//        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);
2031
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2032
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2033
            int64_t delta= pkt_dts - ist->next_pts;
2034
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2035
                input_files_ts_offset[ist->file_index]-= delta;
2036
                if (verbose > 2)
2037
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2038
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2039
                if(pkt.pts != AV_NOPTS_VALUE)
2040
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2041
            }
2042
        }
2043

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

    
2047
            if (verbose >= 0)
2048
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2049
                        ist->file_index, ist->index);
2050

    
2051
            av_free_packet(&pkt);
2052
            goto redo;
2053
        }
2054

    
2055
    discard_packet:
2056
        av_free_packet(&pkt);
2057

    
2058
        /* dump report by using the output first video and audio streams */
2059
        print_report(output_files, ost_table, nb_ostreams, 0);
2060
    }
2061

    
2062
    /* at the end of stream, we must flush the decoder buffers */
2063
    for(i=0;i<nb_istreams;i++) {
2064
        ist = ist_table[i];
2065
        if (ist->decoding_needed) {
2066
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2067
        }
2068
    }
2069

    
2070
    term_exit();
2071

    
2072
    /* write the trailer if needed and close file */
2073
    for(i=0;i<nb_output_files;i++) {
2074
        os = output_files[i];
2075
        av_write_trailer(os);
2076
    }
2077

    
2078
    /* dump report by using the first video and audio streams */
2079
    print_report(output_files, ost_table, nb_ostreams, 1);
2080

    
2081
    /* close each encoder */
2082
    for(i=0;i<nb_ostreams;i++) {
2083
        ost = ost_table[i];
2084
        if (ost->encoding_needed) {
2085
            av_freep(&ost->st->codec->stats_in);
2086
            avcodec_close(ost->st->codec);
2087
        }
2088
    }
2089

    
2090
    /* close each decoder */
2091
    for(i=0;i<nb_istreams;i++) {
2092
        ist = ist_table[i];
2093
        if (ist->decoding_needed) {
2094
            avcodec_close(ist->st->codec);
2095
        }
2096
    }
2097

    
2098
    /* finished ! */
2099

    
2100
    ret = 0;
2101
 fail1:
2102
    av_freep(&bit_buffer);
2103
    av_free(file_table);
2104

    
2105
    if (ist_table) {
2106
        for(i=0;i<nb_istreams;i++) {
2107
            ist = ist_table[i];
2108
            av_free(ist);
2109
        }
2110
        av_free(ist_table);
2111
    }
2112
    if (ost_table) {
2113
        for(i=0;i<nb_ostreams;i++) {
2114
            ost = ost_table[i];
2115
            if (ost) {
2116
                if (ost->logfile) {
2117
                    fclose(ost->logfile);
2118
                    ost->logfile = NULL;
2119
                }
2120
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2121
                                             initialized but set to zero */
2122
                av_free(ost->pict_tmp.data[0]);
2123
                if (ost->video_resample)
2124
                    sws_freeContext(ost->img_resample_ctx);
2125
                if (ost->resample)
2126
                    audio_resample_close(ost->resample);
2127
                av_free(ost);
2128
            }
2129
        }
2130
        av_free(ost_table);
2131
    }
2132
    return ret;
2133
 fail:
2134
    ret = AVERROR(ENOMEM);
2135
    goto fail1;
2136
}
2137

    
2138
#if 0
2139
int file_read(const char *filename)
2140
{
2141
    URLContext *h;
2142
    unsigned char buffer[1024];
2143
    int len, i;
2144

2145
    if (url_open(&h, filename, O_RDONLY) < 0) {
2146
        printf("could not open '%s'\n", filename);
2147
        return -1;
2148
    }
2149
    for(;;) {
2150
        len = url_read(h, buffer, sizeof(buffer));
2151
        if (len <= 0)
2152
            break;
2153
        for(i=0;i<len;i++) putchar(buffer[i]);
2154
    }
2155
    url_close(h);
2156
    return 0;
2157
}
2158
#endif
2159

    
2160
static void opt_format(const char *arg)
2161
{
2162
    /* compatibility stuff for pgmyuv */
2163
    if (!strcmp(arg, "pgmyuv")) {
2164
        pgmyuv_compatibility_hack=1;
2165
//        opt_image_format(arg);
2166
        arg = "image2";
2167
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2168
    }
2169

    
2170
    file_iformat = av_find_input_format(arg);
2171
    file_oformat = guess_format(arg, NULL, NULL);
2172
    if (!file_iformat && !file_oformat) {
2173
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2174
        exit(1);
2175
    }
2176
}
2177

    
2178
extern int ffm_nopts;
2179

    
2180
static int opt_default(const char *opt, const char *arg){
2181
    int type;
2182
    const AVOption *o= NULL;
2183
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2184

    
2185
    for(type=0; type<CODEC_TYPE_NB; type++){
2186
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2187
        if(o2)
2188
            o = av_set_string(avctx_opts[type], opt, arg);
2189
    }
2190
    if(!o)
2191
        o = av_set_string(avformat_opts, opt, arg);
2192
    if(!o)
2193
        o = av_set_string(sws_opts, opt, arg);
2194
    if(!o){
2195
        if(opt[0] == 'a')
2196
            o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2197
        else if(opt[0] == 'v')
2198
            o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2199
        else if(opt[0] == 's')
2200
            o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2201
    }
2202
    if(!o)
2203
        return -1;
2204

    
2205
//    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));
2206

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

    
2211
#if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2212
    /* disable generate of real time pts in ffm (need to be supressed anyway) */
2213
    if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2214
        ffm_nopts = 1;
2215
#endif
2216

    
2217
    if(avctx_opts[0]->debug)
2218
        av_log_set_level(AV_LOG_DEBUG);
2219
    return 0;
2220
}
2221

    
2222
static void opt_video_rc_override_string(const char *arg)
2223
{
2224
    video_rc_override_string = arg;
2225
}
2226

    
2227
static void opt_me_threshold(const char *arg)
2228
{
2229
    me_threshold = atoi(arg);
2230
}
2231

    
2232
static void opt_verbose(const char *arg)
2233
{
2234
    verbose = atoi(arg);
2235
    av_log_set_level(verbose);
2236
}
2237

    
2238
static void opt_frame_rate(const char *arg)
2239
{
2240
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2241
        fprintf(stderr, "Incorrect frame rate\n");
2242
        exit(1);
2243
    }
2244
}
2245

    
2246
static int opt_bitrate(const char *opt, const char *arg)
2247
{
2248
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2249

    
2250
    opt_default(opt, arg);
2251

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

    
2255
    return 0;
2256
}
2257

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

    
2276
static void opt_frame_crop_bottom(const char *arg)
2277
{
2278
    frame_bottomBand = atoi(arg);
2279
    if (frame_bottomBand < 0) {
2280
        fprintf(stderr, "Incorrect bottom crop size\n");
2281
        exit(1);
2282
    }
2283
    if ((frame_bottomBand % 2) != 0) {
2284
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2285
        exit(1);
2286
    }
2287
    if ((frame_bottomBand) >= frame_height){
2288
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2289
        exit(1);
2290
    }
2291
    frame_height -= frame_bottomBand;
2292
}
2293

    
2294
static void opt_frame_crop_left(const char *arg)
2295
{
2296
    frame_leftBand = atoi(arg);
2297
    if (frame_leftBand < 0) {
2298
        fprintf(stderr, "Incorrect left crop size\n");
2299
        exit(1);
2300
    }
2301
    if ((frame_leftBand % 2) != 0) {
2302
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2303
        exit(1);
2304
    }
2305
    if ((frame_leftBand) >= frame_width){
2306
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2307
        exit(1);
2308
    }
2309
    frame_width -= frame_leftBand;
2310
}
2311

    
2312
static void opt_frame_crop_right(const char *arg)
2313
{
2314
    frame_rightBand = atoi(arg);
2315
    if (frame_rightBand < 0) {
2316
        fprintf(stderr, "Incorrect right crop size\n");
2317
        exit(1);
2318
    }
2319
    if ((frame_rightBand % 2) != 0) {
2320
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2321
        exit(1);
2322
    }
2323
    if ((frame_rightBand) >= frame_width){
2324
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2325
        exit(1);
2326
    }
2327
    frame_width -= frame_rightBand;
2328
}
2329

    
2330
static void opt_frame_size(const char *arg)
2331
{
2332
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2333
        fprintf(stderr, "Incorrect frame size\n");
2334
        exit(1);
2335
    }
2336
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2337
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2338
        exit(1);
2339
    }
2340
}
2341

    
2342

    
2343
#define SCALEBITS 10
2344
#define ONE_HALF  (1 << (SCALEBITS - 1))
2345
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2346

    
2347
#define RGB_TO_Y(r, g, b) \
2348
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2349
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2350

    
2351
#define RGB_TO_U(r1, g1, b1, shift)\
2352
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2353
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2354

    
2355
#define RGB_TO_V(r1, g1, b1, shift)\
2356
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2357
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2358

    
2359
static void opt_pad_color(const char *arg) {
2360
    /* Input is expected to be six hex digits similar to
2361
       how colors are expressed in html tags (but without the #) */
2362
    int rgb = strtol(arg, NULL, 16);
2363
    int r,g,b;
2364

    
2365
    r = (rgb >> 16);
2366
    g = ((rgb >> 8) & 255);
2367
    b = (rgb & 255);
2368

    
2369
    padcolor[0] = RGB_TO_Y(r,g,b);
2370
    padcolor[1] = RGB_TO_U(r,g,b,0);
2371
    padcolor[2] = RGB_TO_V(r,g,b,0);
2372
}
2373

    
2374
static void opt_frame_pad_top(const char *arg)
2375
{
2376
    frame_padtop = atoi(arg);
2377
    if (frame_padtop < 0) {
2378
        fprintf(stderr, "Incorrect top pad size\n");
2379
        exit(1);
2380
    }
2381
    if ((frame_padtop % 2) != 0) {
2382
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2383
        exit(1);
2384
    }
2385
}
2386

    
2387
static void opt_frame_pad_bottom(const char *arg)
2388
{
2389
    frame_padbottom = atoi(arg);
2390
    if (frame_padbottom < 0) {
2391
        fprintf(stderr, "Incorrect bottom pad size\n");
2392
        exit(1);
2393
    }
2394
    if ((frame_padbottom % 2) != 0) {
2395
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2396
        exit(1);
2397
    }
2398
}
2399

    
2400

    
2401
static void opt_frame_pad_left(const char *arg)
2402
{
2403
    frame_padleft = atoi(arg);
2404
    if (frame_padleft < 0) {
2405
        fprintf(stderr, "Incorrect left pad size\n");
2406
        exit(1);
2407
    }
2408
    if ((frame_padleft % 2) != 0) {
2409
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2410
        exit(1);
2411
    }
2412
}
2413

    
2414

    
2415
static void opt_frame_pad_right(const char *arg)
2416
{
2417
    frame_padright = atoi(arg);
2418
    if (frame_padright < 0) {
2419
        fprintf(stderr, "Incorrect right pad size\n");
2420
        exit(1);
2421
    }
2422
    if ((frame_padright % 2) != 0) {
2423
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2424
        exit(1);
2425
    }
2426
}
2427

    
2428
void list_pix_fmts(void)
2429
{
2430
    int i;
2431
    char pix_fmt_str[128];
2432
    for (i=-1; i < PIX_FMT_NB; i++) {
2433
        avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2434
        fprintf(stdout, "%s\n", pix_fmt_str);
2435
    }
2436
}
2437

    
2438
static void opt_frame_pix_fmt(const char *arg)
2439
{
2440
    if (strcmp(arg, "list"))
2441
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2442
    else {
2443
        list_pix_fmts();
2444
        exit(0);
2445
    }
2446
}
2447

    
2448
static void opt_frame_aspect_ratio(const char *arg)
2449
{
2450
    int x = 0, y = 0;
2451
    double ar = 0;
2452
    const char *p;
2453
    char *end;
2454

    
2455
    p = strchr(arg, ':');
2456
    if (p) {
2457
        x = strtol(arg, &end, 10);
2458
        if (end == p)
2459
            y = strtol(end+1, &end, 10);
2460
        if (x > 0 && y > 0)
2461
            ar = (double)x / (double)y;
2462
    } else
2463
        ar = strtod(arg, NULL);
2464

    
2465
    if (!ar) {
2466
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2467
        exit(1);
2468
    }
2469
    frame_aspect_ratio = ar;
2470
}
2471

    
2472
static void opt_qscale(const char *arg)
2473
{
2474
    video_qscale = atof(arg);
2475
    if (video_qscale <= 0 ||
2476
        video_qscale > 255) {
2477
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2478
        exit(1);
2479
    }
2480
}
2481

    
2482
static void opt_qdiff(const char *arg)
2483
{
2484
    video_qdiff = atoi(arg);
2485
    if (video_qdiff < 0 ||
2486
        video_qdiff > 31) {
2487
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2488
        exit(1);
2489
    }
2490
}
2491

    
2492
static void opt_strict(const char *arg)
2493
{
2494
    strict= atoi(arg);
2495
}
2496

    
2497
static void opt_top_field_first(const char *arg)
2498
{
2499
    top_field_first= atoi(arg);
2500
}
2501

    
2502
static void opt_thread_count(const char *arg)
2503
{
2504
    thread_count= atoi(arg);
2505
#if !defined(HAVE_THREADS)
2506
    if (verbose >= 0)
2507
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2508
#endif
2509
}
2510

    
2511
static void opt_audio_rate(const char *arg)
2512
{
2513
    audio_sample_rate = atoi(arg);
2514
}
2515

    
2516
static void opt_audio_channels(const char *arg)
2517
{
2518
    audio_channels = atoi(arg);
2519
}
2520

    
2521
static void opt_video_channel(const char *arg)
2522
{
2523
    video_channel = strtol(arg, NULL, 0);
2524
}
2525

    
2526
static void opt_video_standard(const char *arg)
2527
{
2528
    video_standard = av_strdup(arg);
2529
}
2530

    
2531
static void opt_codec(int *pstream_copy, char **pcodec_name,
2532
                      int codec_type, const char *arg)
2533
{
2534
    av_freep(pcodec_name);
2535
    if (!strcmp(arg, "copy")) {
2536
        *pstream_copy = 1;
2537
    } else {
2538
        *pcodec_name = av_strdup(arg);
2539
    }
2540
}
2541

    
2542
static void opt_audio_codec(const char *arg)
2543
{
2544
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2545
}
2546

    
2547
static void opt_audio_tag(const char *arg)
2548
{
2549
    char *tail;
2550
    audio_codec_tag= strtol(arg, &tail, 0);
2551

    
2552
    if(!tail || *tail)
2553
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2554
}
2555

    
2556
static void opt_video_tag(const char *arg)
2557
{
2558
    char *tail;
2559
    video_codec_tag= strtol(arg, &tail, 0);
2560

    
2561
    if(!tail || *tail)
2562
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2563
}
2564

    
2565
#ifdef CONFIG_VHOOK
2566
static void add_frame_hooker(const char *arg)
2567
{
2568
    int argc = 0;
2569
    char *argv[64];
2570
    int i;
2571
    char *args = av_strdup(arg);
2572

    
2573
    using_vhook = 1;
2574

    
2575
    argv[0] = strtok(args, " ");
2576
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2577
    }
2578

    
2579
    i = frame_hook_add(argc, argv);
2580

    
2581
    if (i != 0) {
2582
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2583
        exit(1);
2584
    }
2585
}
2586
#endif
2587

    
2588
static void opt_video_codec(const char *arg)
2589
{
2590
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2591
}
2592

    
2593
static void opt_subtitle_codec(const char *arg)
2594
{
2595
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2596
}
2597

    
2598
static void opt_map(const char *arg)
2599
{
2600
    AVStreamMap *m;
2601
    char *p;
2602

    
2603
    m = &stream_maps[nb_stream_maps++];
2604

    
2605
    m->file_index = strtol(arg, &p, 0);
2606
    if (*p)
2607
        p++;
2608

    
2609
    m->stream_index = strtol(p, &p, 0);
2610
    if (*p) {
2611
        p++;
2612
        m->sync_file_index = strtol(p, &p, 0);
2613
        if (*p)
2614
            p++;
2615
        m->sync_stream_index = strtol(p, &p, 0);
2616
    } else {
2617
        m->sync_file_index = m->file_index;
2618
        m->sync_stream_index = m->stream_index;
2619
    }
2620
}
2621

    
2622
static void opt_map_meta_data(const char *arg)
2623
{
2624
    AVMetaDataMap *m;
2625
    char *p;
2626

    
2627
    m = &meta_data_maps[nb_meta_data_maps++];
2628

    
2629
    m->out_file = strtol(arg, &p, 0);
2630
    if (*p)
2631
        p++;
2632

    
2633
    m->in_file = strtol(p, &p, 0);
2634
}
2635

    
2636
static int opt_recording_time(const char *opt, const char *arg)
2637
{
2638
    recording_time = parse_time_or_die(opt, arg, 1);
2639
    return 0;
2640
}
2641

    
2642
static int opt_start_time(const char *opt, const char *arg)
2643
{
2644
    start_time = parse_time_or_die(opt, arg, 1);
2645
    return 0;
2646
}
2647

    
2648
static int opt_rec_timestamp(const char *opt, const char *arg)
2649
{
2650
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2651
    return 0;
2652
}
2653

    
2654
static int opt_input_ts_offset(const char *opt, const char *arg)
2655
{
2656
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2657
    return 0;
2658
}
2659

    
2660
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2661
{
2662
    const char *codec_string = encoder ? "encoder" : "decoder";
2663
    AVCodec *codec;
2664

    
2665
    if(!name)
2666
        return CODEC_ID_NONE;
2667
    codec = encoder ?
2668
        avcodec_find_encoder_by_name(name) :
2669
        avcodec_find_decoder_by_name(name);
2670
    if(!codec) {
2671
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2672
        exit(1);
2673
    }
2674
    if(codec->type != type) {
2675
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2676
        exit(1);
2677
    }
2678
    return codec->id;
2679
}
2680

    
2681
static void opt_input_file(const char *filename)
2682
{
2683
    AVFormatContext *ic;
2684
    AVFormatParameters params, *ap = &params;
2685
    int err, i, ret, rfps, rfps_base;
2686
    int64_t timestamp;
2687

    
2688
    if (!strcmp(filename, "-"))
2689
        filename = "pipe:";
2690

    
2691
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2692
                   !strcmp( filename, "/dev/stdin" );
2693

    
2694
    /* get default parameters from command line */
2695
    ic = av_alloc_format_context();
2696

    
2697
    memset(ap, 0, sizeof(*ap));
2698
    ap->prealloced_context = 1;
2699
    ap->sample_rate = audio_sample_rate;
2700
    ap->channels = audio_channels;
2701
    ap->time_base.den = frame_rate.num;
2702
    ap->time_base.num = frame_rate.den;
2703
    ap->width = frame_width + frame_padleft + frame_padright;
2704
    ap->height = frame_height + frame_padtop + frame_padbottom;
2705
    ap->pix_fmt = frame_pix_fmt;
2706
    ap->channel = video_channel;
2707
    ap->standard = video_standard;
2708
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2709
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2710
    if(pgmyuv_compatibility_hack)
2711
        ap->video_codec_id= CODEC_ID_PGMYUV;
2712

    
2713
    for(i=0; i<opt_name_count; i++){
2714
        char buf[256];
2715
        const AVOption *opt;
2716
        const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2717
        if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2718
            av_set_string(ic, opt_names[i], str);
2719
    }
2720

    
2721
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2722
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2723
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2724

    
2725
    /* open the input file with generic libav function */
2726
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2727
    if (err < 0) {
2728
        print_error(filename, err);
2729
        exit(1);
2730
    }
2731
    if(opt_programid) {
2732
        int i;
2733
        for(i=0; i<ic->nb_programs; i++)
2734
            if(ic->programs[i]->id != opt_programid)
2735
                ic->programs[i]->discard = AVDISCARD_ALL;
2736
    }
2737

    
2738
    ic->loop_input = loop_input;
2739

    
2740
    /* If not enough info to get the stream parameters, we decode the
2741
       first frames to get it. (used in mpeg case for example) */
2742
    ret = av_find_stream_info(ic);
2743
    if (ret < 0 && verbose >= 0) {
2744
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2745
        exit(1);
2746
    }
2747

    
2748
    timestamp = start_time;
2749
    /* add the stream start time */
2750
    if (ic->start_time != AV_NOPTS_VALUE)
2751
        timestamp += ic->start_time;
2752

    
2753
    /* if seeking requested, we execute it */
2754
    if (start_time != 0) {
2755
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2756
        if (ret < 0) {
2757
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2758
                    filename, (double)timestamp / AV_TIME_BASE);
2759
        }
2760
        /* reset seek info */
2761
        start_time = 0;
2762
    }
2763

    
2764
    /* update the current parameters so that they match the one of the input stream */
2765
    for(i=0;i<ic->nb_streams;i++) {
2766
        int j;
2767
        AVCodecContext *enc = ic->streams[i]->codec;
2768
        if(thread_count>1)
2769
            avcodec_thread_init(enc, thread_count);
2770
        enc->thread_count= thread_count;
2771
        switch(enc->codec_type) {
2772
        case CODEC_TYPE_AUDIO:
2773
            for(j=0; j<opt_name_count; j++){
2774
                char buf[256];
2775
                const AVOption *opt;
2776
                const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2777
                if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2778
                    av_set_string(enc, opt_names[j], str);
2779
            }
2780
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2781
            audio_channels = enc->channels;
2782
            audio_sample_rate = enc->sample_rate;
2783
            if(audio_disable)
2784
                ic->streams[i]->discard= AVDISCARD_ALL;
2785
            break;
2786
        case CODEC_TYPE_VIDEO:
2787
            for(j=0; j<opt_name_count; j++){
2788
                char buf[256];
2789
                const AVOption *opt;
2790
                const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2791
                if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2792
                    av_set_string(enc, opt_names[j], str);
2793
            }
2794
            frame_height = enc->height;
2795
            frame_width = enc->width;
2796
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2797
            frame_pix_fmt = enc->pix_fmt;
2798
            rfps      = ic->streams[i]->r_frame_rate.num;
2799
            rfps_base = ic->streams[i]->r_frame_rate.den;
2800
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2801
            if(me_threshold)
2802
                enc->debug |= FF_DEBUG_MV;
2803

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

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

    
2810
                    (float)rfps / rfps_base, rfps, rfps_base);
2811
            }
2812
            /* update the current frame rate to match the stream frame rate */
2813
            frame_rate.num = rfps;
2814
            frame_rate.den = rfps_base;
2815

    
2816
            enc->rate_emu = rate_emu;
2817
            if(video_disable)
2818
                ic->streams[i]->discard= AVDISCARD_ALL;
2819
            else if(video_discard)
2820
                ic->streams[i]->discard= video_discard;
2821
            break;
2822
        case CODEC_TYPE_DATA:
2823
            break;
2824
        case CODEC_TYPE_SUBTITLE:
2825
            if(subtitle_disable)
2826
                ic->streams[i]->discard = AVDISCARD_ALL;
2827
            break;
2828
        case CODEC_TYPE_ATTACHMENT:
2829
        case CODEC_TYPE_UNKNOWN:
2830
            break;
2831
        default:
2832
            abort();
2833
        }
2834
    }
2835

    
2836
    input_files[nb_input_files] = ic;
2837
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2838
    /* dump the file content */
2839
    if (verbose >= 0)
2840
        dump_format(ic, nb_input_files, filename, 0);
2841

    
2842
    nb_input_files++;
2843
    file_iformat = NULL;
2844
    file_oformat = NULL;
2845

    
2846
    video_channel = 0;
2847

    
2848
    rate_emu = 0;
2849
    av_freep(&video_codec_name);
2850
    av_freep(&audio_codec_name);
2851
    av_freep(&subtitle_codec_name);
2852
}
2853

    
2854
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2855
                                         int *has_subtitle_ptr)
2856
{
2857
    int has_video, has_audio, has_subtitle, i, j;
2858
    AVFormatContext *ic;
2859

    
2860
    has_video = 0;
2861
    has_audio = 0;
2862
    has_subtitle = 0;
2863
    for(j=0;j<nb_input_files;j++) {
2864
        ic = input_files[j];
2865
        for(i=0;i<ic->nb_streams;i++) {
2866
            AVCodecContext *enc = ic->streams[i]->codec;
2867
            switch(enc->codec_type) {
2868
            case CODEC_TYPE_AUDIO:
2869
                has_audio = 1;
2870
                break;
2871
            case CODEC_TYPE_VIDEO:
2872
                has_video = 1;
2873
                break;
2874
            case CODEC_TYPE_SUBTITLE:
2875
                has_subtitle = 1;
2876
                break;
2877
            case CODEC_TYPE_DATA:
2878
            case CODEC_TYPE_ATTACHMENT:
2879
            case CODEC_TYPE_UNKNOWN:
2880
                break;
2881
            default:
2882
                abort();
2883
            }
2884
        }
2885
    }
2886
    *has_video_ptr = has_video;
2887
    *has_audio_ptr = has_audio;
2888
    *has_subtitle_ptr = has_subtitle;
2889
}
2890

    
2891
static void new_video_stream(AVFormatContext *oc)
2892
{
2893
    AVStream *st;
2894
    AVCodecContext *video_enc;
2895
    int codec_id;
2896

    
2897
    st = av_new_stream(oc, oc->nb_streams);
2898
    if (!st) {
2899
        fprintf(stderr, "Could not alloc stream\n");
2900
        exit(1);
2901
    }
2902
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2903
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2904
    video_bitstream_filters= NULL;
2905

    
2906
    if(thread_count>1)
2907
        avcodec_thread_init(st->codec, thread_count);
2908

    
2909
    video_enc = st->codec;
2910

    
2911
    if(video_codec_tag)
2912
        video_enc->codec_tag= video_codec_tag;
2913

    
2914
    if(   (video_global_header&1)
2915
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2916
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2917
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2918
    }
2919
    if(video_global_header&2){
2920
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2921
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2922
    }
2923

    
2924
    if (video_stream_copy) {
2925
        st->stream_copy = 1;
2926
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2927
    } else {
2928
        const char *p;
2929
        int i;
2930
        AVCodec *codec;
2931
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2932

    
2933
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2934
        if (video_codec_name)
2935
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2936

    
2937
        video_enc->codec_id = codec_id;
2938
        codec = avcodec_find_encoder(codec_id);
2939

    
2940
        for(i=0; i<opt_name_count; i++){
2941
            char buf[256];
2942
            const AVOption *opt;
2943
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2944
            if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2945
                av_set_string(video_enc, opt_names[i], str);
2946
        }
2947

    
2948
        video_enc->time_base.den = fps.num;
2949
        video_enc->time_base.num = fps.den;
2950
        if(codec && codec->supported_framerates){
2951
            const AVRational *p= codec->supported_framerates;
2952
            const AVRational *best=NULL;
2953
            AVRational best_error= (AVRational){INT_MAX, 1};
2954
            for(; p->den!=0; p++){
2955
                AVRational error= av_sub_q(fps, *p);
2956
                if(error.num <0) error.num *= -1;
2957
                if(av_cmp_q(error, best_error) < 0){
2958
                    best_error= error;
2959
                    best= p;
2960
                }
2961
            }
2962
            video_enc->time_base.den= best->num;
2963
            video_enc->time_base.num= best->den;
2964
        }
2965

    
2966
        video_enc->width = frame_width + frame_padright + frame_padleft;
2967
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2968
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2969
        video_enc->pix_fmt = frame_pix_fmt;
2970

    
2971
        if(codec && codec->pix_fmts){
2972
            const enum PixelFormat *p= codec->pix_fmts;
2973
            for(; *p!=-1; p++){
2974
                if(*p == video_enc->pix_fmt)
2975
                    break;
2976
            }
2977
            if(*p == -1)
2978
                video_enc->pix_fmt = codec->pix_fmts[0];
2979
        }
2980

    
2981
        if (intra_only)
2982
            video_enc->gop_size = 0;
2983
        if (video_qscale || same_quality) {
2984
            video_enc->flags |= CODEC_FLAG_QSCALE;
2985
            video_enc->global_quality=
2986
                st->quality = FF_QP2LAMBDA * video_qscale;
2987
        }
2988

    
2989
        if(intra_matrix)
2990
            video_enc->intra_matrix = intra_matrix;
2991
        if(inter_matrix)
2992
            video_enc->inter_matrix = inter_matrix;
2993

    
2994
        video_enc->max_qdiff = video_qdiff;
2995
        video_enc->thread_count = thread_count;
2996
        p= video_rc_override_string;
2997
        for(i=0; p; i++){
2998
            int start, end, q;
2999
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3000
            if(e!=3){
3001
                fprintf(stderr, "error parsing rc_override\n");
3002
                exit(1);
3003
            }
3004
            video_enc->rc_override=
3005
                av_realloc(video_enc->rc_override,
3006
                           sizeof(RcOverride)*(i+1));
3007
            video_enc->rc_override[i].start_frame= start;
3008
            video_enc->rc_override[i].end_frame  = end;
3009
            if(q>0){
3010
                video_enc->rc_override[i].qscale= q;
3011
                video_enc->rc_override[i].quality_factor= 1.0;
3012
            }
3013
            else{
3014
                video_enc->rc_override[i].qscale= 0;
3015
                video_enc->rc_override[i].quality_factor= -q/100.0;
3016
            }
3017
            p= strchr(p, '/');
3018
            if(p) p++;
3019
        }
3020
        video_enc->rc_override_count=i;
3021
        if (!video_enc->rc_initial_buffer_occupancy)
3022
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3023
        video_enc->me_threshold= me_threshold;
3024
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3025
        video_enc->strict_std_compliance = strict;
3026

    
3027
        if (do_psnr)
3028
            video_enc->flags|= CODEC_FLAG_PSNR;
3029

    
3030
        /* two pass mode */
3031
        if (do_pass) {
3032
            if (do_pass == 1) {
3033
                video_enc->flags |= CODEC_FLAG_PASS1;
3034
            } else {
3035
                video_enc->flags |= CODEC_FLAG_PASS2;
3036
            }
3037
        }
3038
    }
3039

    
3040
    /* reset some key parameters */
3041
    video_disable = 0;
3042
    av_freep(&video_codec_name);
3043
    video_stream_copy = 0;
3044
}
3045

    
3046
static void new_audio_stream(AVFormatContext *oc)
3047
{
3048
    AVStream *st;
3049
    AVCodecContext *audio_enc;
3050
    int codec_id, i;
3051

    
3052
    st = av_new_stream(oc, oc->nb_streams);
3053
    if (!st) {
3054
        fprintf(stderr, "Could not alloc stream\n");
3055
        exit(1);
3056
    }
3057
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3058

    
3059
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3060
    audio_bitstream_filters= NULL;
3061

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

    
3065
    audio_enc = st->codec;
3066
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3067
    audio_enc->strict_std_compliance = strict;
3068

    
3069
    if(audio_codec_tag)
3070
        audio_enc->codec_tag= audio_codec_tag;
3071

    
3072
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3073
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3074
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3075
    }
3076
    if (audio_stream_copy) {
3077
        st->stream_copy = 1;
3078
        audio_enc->channels = audio_channels;
3079
    } else {
3080
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3081

    
3082
        for(i=0; i<opt_name_count; i++){
3083
            char buf[256];
3084
            const AVOption *opt;
3085
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3086
            if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3087
                av_set_string(audio_enc, opt_names[i], str);
3088
        }
3089

    
3090
        if (audio_codec_name)
3091
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3092
        audio_enc->codec_id = codec_id;
3093

    
3094
        if (audio_qscale > QSCALE_NONE) {
3095
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3096
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3097
        }
3098
        audio_enc->thread_count = thread_count;
3099
        audio_enc->channels = audio_channels;
3100
    }
3101
    audio_enc->sample_rate = audio_sample_rate;
3102
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3103
    if (audio_language) {
3104
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3105
        av_free(audio_language);
3106
        audio_language = NULL;
3107
    }
3108

    
3109
    /* reset some key parameters */
3110
    audio_disable = 0;
3111
    av_freep(&audio_codec_name);
3112
    audio_stream_copy = 0;
3113
}
3114

    
3115
static void new_subtitle_stream(AVFormatContext *oc)
3116
{
3117
    AVStream *st;
3118
    AVCodecContext *subtitle_enc;
3119
    int i;
3120

    
3121
    st = av_new_stream(oc, oc->nb_streams);
3122
    if (!st) {
3123
        fprintf(stderr, "Could not alloc stream\n");
3124
        exit(1);
3125
    }
3126
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3127

    
3128
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3129
    subtitle_bitstream_filters= NULL;
3130

    
3131
    subtitle_enc = st->codec;
3132
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3133
    if (subtitle_stream_copy) {
3134
        st->stream_copy = 1;
3135
    } else {
3136
        for(i=0; i<opt_name_count; i++){
3137
            char buf[256];
3138
            const AVOption *opt;
3139
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3140
            if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3141
                av_set_string(subtitle_enc, opt_names[i], str);
3142
        }
3143
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3144
    }
3145

    
3146
    if (subtitle_language) {
3147
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3148
        av_free(subtitle_language);
3149
        subtitle_language = NULL;
3150
    }
3151

    
3152
    subtitle_disable = 0;
3153
    av_freep(&subtitle_codec_name);
3154
    subtitle_stream_copy = 0;
3155
}
3156

    
3157
static void opt_new_audio_stream(void)
3158
{
3159
    AVFormatContext *oc;
3160
    if (nb_output_files <= 0) {
3161
        fprintf(stderr, "At least one output file must be specified\n");
3162
        exit(1);
3163
    }
3164
    oc = output_files[nb_output_files - 1];
3165
    new_audio_stream(oc);
3166
}
3167

    
3168
static void opt_new_video_stream(void)
3169
{
3170
    AVFormatContext *oc;
3171
    if (nb_output_files <= 0) {
3172
        fprintf(stderr, "At least one output file must be specified\n");
3173
        exit(1);
3174
    }
3175
    oc = output_files[nb_output_files - 1];
3176
    new_video_stream(oc);
3177
}
3178

    
3179
static void opt_new_subtitle_stream(void)
3180
{
3181
    AVFormatContext *oc;
3182
    if (nb_output_files <= 0) {
3183
        fprintf(stderr, "At least one output file must be specified\n");
3184
        exit(1);
3185
    }
3186
    oc = output_files[nb_output_files - 1];
3187
    new_subtitle_stream(oc);
3188
}
3189

    
3190
static void opt_output_file(const char *filename)
3191
{
3192
    AVFormatContext *oc;
3193
    int use_video, use_audio, use_subtitle;
3194
    int input_has_video, input_has_audio, input_has_subtitle, i;
3195
    AVFormatParameters params, *ap = &params;
3196

    
3197
    if (!strcmp(filename, "-"))
3198
        filename = "pipe:";
3199

    
3200
    oc = av_alloc_format_context();
3201

    
3202
    if (!file_oformat) {
3203
        file_oformat = guess_format(NULL, filename, NULL);
3204
        if (!file_oformat) {
3205
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3206
                    filename);
3207
            exit(1);
3208
        }
3209
    }
3210

    
3211
    oc->oformat = file_oformat;
3212
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3213

    
3214
    if (!strcmp(file_oformat->name, "ffm") &&
3215
        av_strstart(filename, "http:", NULL)) {
3216
        /* special case for files sent to ffserver: we get the stream
3217
           parameters from ffserver */
3218
        if (read_ffserver_streams(oc, filename) < 0) {
3219
            fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3220
            exit(1);
3221
        }
3222
    } else {
3223
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3224
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3225
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3226

    
3227
        /* disable if no corresponding type found and at least one
3228
           input file */
3229
        if (nb_input_files > 0) {
3230
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3231
                                         &input_has_subtitle);
3232
            if (!input_has_video)
3233
                use_video = 0;
3234
            if (!input_has_audio)
3235
                use_audio = 0;
3236
            if (!input_has_subtitle)
3237
                use_subtitle = 0;
3238
        }
3239

    
3240
        /* manual disable */
3241
        if (audio_disable) {
3242
            use_audio = 0;
3243
        }
3244
        if (video_disable) {
3245
            use_video = 0;
3246
        }
3247
        if (subtitle_disable) {
3248
            use_subtitle = 0;
3249
        }
3250

    
3251
        if (use_video) {
3252
            new_video_stream(oc);
3253
        }
3254

    
3255
        if (use_audio) {
3256
            new_audio_stream(oc);
3257
        }
3258

    
3259
        if (use_subtitle) {
3260
            new_subtitle_stream(oc);
3261
        }
3262

    
3263
        oc->timestamp = rec_timestamp;
3264

    
3265
        if (str_title)
3266
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3267
        if (str_author)
3268
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3269
        if (str_copyright)
3270
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3271
        if (str_comment)
3272
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3273
        if (str_album)
3274
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3275
        if (str_genre)
3276
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3277
    }
3278

    
3279
    output_files[nb_output_files++] = oc;
3280

    
3281
    /* check filename in case of an image number is expected */
3282
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3283
        if (!av_filename_number_test(oc->filename)) {
3284
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3285
            exit(1);
3286
        }
3287
    }
3288

    
3289
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3290
        /* test if it already exists to avoid loosing precious files */
3291
        if (!file_overwrite &&
3292
            (strchr(filename, ':') == NULL ||
3293
             filename[1] == ':' ||
3294
             av_strstart(filename, "file:", NULL))) {
3295
            if (url_exist(filename)) {
3296
                int c;
3297

    
3298
                if ( !using_stdin ) {
3299
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3300
                    fflush(stderr);
3301
                    c = getchar();
3302
                    if (toupper(c) != 'Y') {
3303
                        fprintf(stderr, "Not overwriting - exiting\n");
3304
                        exit(1);
3305
                    }
3306
                                }
3307
                                else {
3308
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3309
                    exit(1);
3310
                                }
3311
            }
3312
        }
3313

    
3314
        /* open the file */
3315
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3316
            fprintf(stderr, "Could not open '%s'\n", filename);
3317
            exit(1);
3318
        }
3319
    }
3320

    
3321
    memset(ap, 0, sizeof(*ap));
3322
    if (av_set_parameters(oc, ap) < 0) {
3323
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3324
                oc->filename);
3325
        exit(1);
3326
    }
3327

    
3328
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3329
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3330
    oc->loop_output = loop_output;
3331

    
3332
    for(i=0; i<opt_name_count; i++){
3333
        char buf[256];
3334
        const AVOption *opt;
3335
        const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3336
        if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3337
            av_set_string(oc, opt_names[i], str);
3338
    }
3339

    
3340
    /* reset some options */
3341
    file_oformat = NULL;
3342
    file_iformat = NULL;
3343
}
3344

    
3345
/* same option as mencoder */
3346
static void opt_pass(const char *pass_str)
3347
{
3348
    int pass;
3349
    pass = atoi(pass_str);
3350
    if (pass != 1 && pass != 2) {
3351
        fprintf(stderr, "pass number can be only 1 or 2\n");
3352
        exit(1);
3353
    }
3354
    do_pass = pass;
3355
}
3356

    
3357
static int64_t getutime(void)
3358
{
3359
#ifdef HAVE_GETRUSAGE
3360
    struct rusage rusage;
3361

    
3362
    getrusage(RUSAGE_SELF, &rusage);
3363
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3364
#elif defined(HAVE_GETPROCESSTIMES)
3365
    HANDLE proc;
3366
    FILETIME c, e, k, u;
3367
    proc = GetCurrentProcess();
3368
    GetProcessTimes(proc, &c, &e, &k, &u);
3369
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3370
#else
3371
    return av_gettime();
3372
#endif
3373
}
3374

    
3375
static void opt_show_formats(void)
3376
{
3377
    AVInputFormat *ifmt=NULL;
3378
    AVOutputFormat *ofmt=NULL;
3379
    URLProtocol *up=NULL;
3380
    AVCodec *p=NULL, *p2;
3381
    AVBitStreamFilter *bsf=NULL;
3382
    const char *last_name;
3383

    
3384
    printf("File formats:\n");
3385
    last_name= "000";
3386
    for(;;){
3387
        int decode=0;
3388
        int encode=0;
3389
        const char *name=NULL;
3390
        const char *long_name=NULL;
3391

    
3392
        while((ofmt= av_oformat_next(ofmt))) {
3393
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3394
                strcmp(ofmt->name, last_name)>0){
3395
                name= ofmt->name;
3396
                long_name= ofmt->long_name;
3397
                encode=1;
3398
            }
3399
        }
3400
        while((ifmt= av_iformat_next(ifmt))) {
3401
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3402
                strcmp(ifmt->name, last_name)>0){
3403
                name= ifmt->name;
3404
                long_name= ifmt->long_name;
3405
                encode=0;
3406
            }
3407
            if(name && strcmp(ifmt->name, name)==0)
3408
                decode=1;
3409
        }
3410
        if(name==NULL)
3411
            break;
3412
        last_name= name;
3413

    
3414
        printf(
3415
            " %s%s %-15s %s\n",
3416
            decode ? "D":" ",
3417
            encode ? "E":" ",
3418
            name,
3419
            long_name ? long_name:" ");
3420
    }
3421
    printf("\n");
3422

    
3423
    printf("Codecs:\n");
3424
    last_name= "000";
3425
    for(;;){
3426
        int decode=0;
3427
        int encode=0;
3428
        int cap=0;
3429
        const char *type_str;
3430

    
3431
        p2=NULL;
3432
        while((p= av_codec_next(p))) {
3433
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3434
                strcmp(p->name, last_name)>0){
3435
                p2= p;
3436
                decode= encode= cap=0;
3437
            }
3438
            if(p2 && strcmp(p->name, p2->name)==0){
3439
                if(p->decode) decode=1;
3440
                if(p->encode) encode=1;
3441
                cap |= p->capabilities;
3442
            }
3443
        }
3444
        if(p2==NULL)
3445
            break;
3446
        last_name= p2->name;
3447

    
3448
        switch(p2->type) {
3449
        case CODEC_TYPE_VIDEO:
3450
            type_str = "V";
3451
            break;
3452
        case CODEC_TYPE_AUDIO:
3453
            type_str = "A";
3454
            break;
3455
        case CODEC_TYPE_SUBTITLE:
3456
            type_str = "S";
3457
            break;
3458
        default:
3459
            type_str = "?";
3460
            break;
3461
        }
3462
        printf(
3463
            " %s%s%s%s%s%s %s",
3464
            decode ? "D": (/*p2->decoder ? "d":*/" "),
3465
            encode ? "E":" ",
3466
            type_str,
3467
            cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3468
            cap & CODEC_CAP_DR1 ? "D":" ",
3469
            cap & CODEC_CAP_TRUNCATED ? "T":" ",
3470
            p2->name);
3471
       /* if(p2->decoder && decode==0)
3472
            printf(" use %s for decoding", p2->decoder->name);*/
3473
        printf("\n");
3474
    }
3475
    printf("\n");
3476

    
3477
    printf("Bitstream filters:\n");
3478
    while((bsf = av_bitstream_filter_next(bsf)))
3479
        printf(" %s", bsf->name);
3480
    printf("\n");
3481

    
3482
    printf("Supported file protocols:\n");
3483
    while((up = av_protocol_next(up)))
3484
        printf(" %s:", up->name);
3485
    printf("\n");
3486

    
3487
    printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3488
    printf("\n");
3489
    printf(
3490
"Note, the names of encoders and decoders do not always match, so there are\n"
3491
"several cases where the above table shows encoder only or decoder only entries\n"
3492
"even though both encoding and decoding are supported. For example, the h263\n"
3493
"decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3494
"worse.\n");
3495
    exit(0);
3496
}
3497

    
3498
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3499
{
3500
    int i;
3501
    const char *p = str;
3502
    for(i = 0;; i++) {
3503
        dest[i] = atoi(p);
3504
        if(i == 63)
3505
            break;
3506
        p = strchr(p, ',');
3507
        if(!p) {
3508
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3509
            exit(1);
3510
        }
3511
        p++;
3512
    }
3513
}
3514

    
3515
static void opt_inter_matrix(const char *arg)
3516
{
3517
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3518
    parse_matrix_coeffs(inter_matrix, arg);
3519
}
3520

    
3521
static void opt_intra_matrix(const char *arg)
3522
{
3523
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3524
    parse_matrix_coeffs(intra_matrix, arg);
3525
}
3526

    
3527
/**
3528
 * Trivial log callback.
3529
 * Only suitable for show_help and similar since it lacks prefix handling.
3530
 */
3531
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3532
{
3533
    vfprintf(stdout, fmt, vl);
3534
}
3535

    
3536
static void show_help(void)
3537
{
3538
    av_log_set_callback(log_callback_help);
3539
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3540
           "Hyper fast Audio and Video encoder\n");
3541
    printf("\n");
3542
    show_help_options(options, "Main options:\n",
3543
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3544
    show_help_options(options, "\nVideo options:\n",
3545
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3546
                      OPT_VIDEO);
3547
    show_help_options(options, "\nAdvanced Video options:\n",
3548
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3549
                      OPT_VIDEO | OPT_EXPERT);
3550
    show_help_options(options, "\nAudio options:\n",
3551
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3552
                      OPT_AUDIO);
3553
    show_help_options(options, "\nAdvanced Audio options:\n",
3554
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3555
                      OPT_AUDIO | OPT_EXPERT);
3556
    show_help_options(options, "\nSubtitle options:\n",
3557
                      OPT_SUBTITLE | OPT_GRAB,
3558
                      OPT_SUBTITLE);
3559
    show_help_options(options, "\nAudio/Video grab options:\n",
3560
                      OPT_GRAB,
3561
                      OPT_GRAB);
3562
    show_help_options(options, "\nAdvanced options:\n",
3563
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3564
                      OPT_EXPERT);
3565
    av_opt_show(avctx_opts[0], NULL);
3566
    av_opt_show(avformat_opts, NULL);
3567
    av_opt_show(sws_opts, NULL);
3568
}
3569

    
3570
static void opt_show_help(void)
3571
{
3572
    show_help();
3573
    exit(0);
3574
}
3575

    
3576
static void opt_target(const char *arg)
3577
{
3578
    int norm = -1;
3579
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3580

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

    
3625
    if(norm < 0) {
3626
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3627
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3628
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3629
        exit(1);
3630
    }
3631

    
3632
    if(!strcmp(arg, "vcd")) {
3633

    
3634
        opt_video_codec("mpeg1video");
3635
        opt_audio_codec("mp2");
3636
        opt_format("vcd");
3637

    
3638
        opt_frame_size(norm ? "352x240" : "352x288");
3639
        opt_frame_rate(frame_rates[norm]);
3640
        opt_default("gop", norm ? "18" : "15");
3641

    
3642
        opt_default("b", "1150000");
3643
        opt_default("maxrate", "1150000");
3644
        opt_default("minrate", "1150000");
3645
        opt_default("bufsize", "327680"); // 40*1024*8;
3646

    
3647
        opt_default("ab", "224000");
3648
        audio_sample_rate = 44100;
3649
        audio_channels = 2;
3650

    
3651
        opt_default("packetsize", "2324");
3652
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3653

    
3654
        /* We have to offset the PTS, so that it is consistent with the SCR.
3655
           SCR starts at 36000, but the first two packs contain only padding
3656
           and the first pack from the other stream, respectively, may also have
3657
           been written before.
3658
           So the real data starts at SCR 36000+3*1200. */
3659
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3660
    } else if(!strcmp(arg, "svcd")) {
3661

    
3662
        opt_video_codec("mpeg2video");
3663
        opt_audio_codec("mp2");
3664
        opt_format("svcd");
3665

    
3666
        opt_frame_size(norm ? "480x480" : "480x576");
3667
        opt_frame_rate(frame_rates[norm]);
3668
        opt_default("gop", norm ? "18" : "15");
3669

    
3670
        opt_default("b", "2040000");
3671
        opt_default("maxrate", "2516000");
3672
        opt_default("minrate", "0"); //1145000;
3673
        opt_default("bufsize", "1835008"); //224*1024*8;
3674
        opt_default("flags", "+SCAN_OFFSET");
3675

    
3676

    
3677
        opt_default("ab", "224000");
3678
        audio_sample_rate = 44100;
3679

    
3680
        opt_default("packetsize", "2324");
3681

    
3682
    } else if(!strcmp(arg, "dvd")) {
3683

    
3684
        opt_video_codec("mpeg2video");
3685
        opt_audio_codec("ac3");
3686
        opt_format("dvd");
3687

    
3688
        opt_frame_size(norm ? "720x480" : "720x576");
3689
        opt_frame_rate(frame_rates[norm]);
3690
        opt_default("gop", norm ? "18" : "15");
3691

    
3692
        opt_default("b", "6000000");
3693
        opt_default("maxrate", "9000000");
3694
        opt_default("minrate", "0"); //1500000;
3695
        opt_default("bufsize", "1835008"); //224*1024*8;
3696

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

    
3700
        opt_default("ab", "448000");
3701
        audio_sample_rate = 48000;
3702

    
3703
    } else if(!strncmp(arg, "dv", 2)) {
3704

    
3705
        opt_format("dv");
3706

    
3707
        opt_frame_size(norm ? "720x480" : "720x576");
3708
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3709
                                             (norm ? "yuv411p" : "yuv420p"));
3710
        opt_frame_rate(frame_rates[norm]);
3711

    
3712
        audio_sample_rate = 48000;
3713
        audio_channels = 2;
3714

    
3715
    } else {
3716
        fprintf(stderr, "Unknown target: %s\n", arg);
3717
        exit(1);
3718
    }
3719
}
3720

    
3721
static void opt_vstats_file (const char *arg)
3722
{
3723
    av_free (vstats_filename);
3724
    vstats_filename=av_strdup (arg);
3725
}
3726

    
3727
static void opt_vstats (void)
3728
{
3729
    char filename[40];
3730
    time_t today2 = time(NULL);
3731
    struct tm *today = localtime(&today2);
3732

    
3733
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3734
             today->tm_sec);
3735
    opt_vstats_file(filename);
3736
}
3737

    
3738
static int opt_bsf(const char *opt, const char *arg)
3739
{
3740
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3741
    AVBitStreamFilterContext **bsfp;
3742

    
3743
    if(!bsfc){
3744
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3745
        exit(1);
3746
    }
3747

    
3748
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3749
          *opt == 'a' ? &audio_bitstream_filters :
3750
                        &subtitle_bitstream_filters;
3751
    while(*bsfp)
3752
        bsfp= &(*bsfp)->next;
3753

    
3754
    *bsfp= bsfc;
3755

    
3756
    return 0;
3757
}
3758

    
3759
static void opt_show_license(void)
3760
{
3761
    show_license();
3762
    exit(0);
3763
}
3764

    
3765
static void opt_show_version(void)
3766
{
3767
    show_version(program_name);
3768
    exit(0);
3769
}
3770

    
3771
const OptionDef options[] = {
3772
    /* main options */
3773
    { "L", 0, {(void*)opt_show_license}, "show license" },
3774
    { "h", 0, {(void*)opt_show_help}, "show help" },
3775
    { "version", 0, {(void*)opt_show_version}, "show version" },
3776
    { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3777
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3778
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3779
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3780
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3781
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3782
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3783
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3784
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3785
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3786
    { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3787
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3788
    { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3789
    { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3790
    { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3791
    { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3792
    { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3793
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3794
      "add timings for benchmarking" },
3795
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3796
      "dump each input packet" },
3797
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3798
      "when dumping packets, also dump the payload" },
3799
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3800
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3801
    { "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)", "" },
3802
    { "v", HAS_ARG, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3803
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3804
    { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3805
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3806
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3807
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3808
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3809
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3810
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3811
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3812
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3813

    
3814
    /* video options */
3815
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3816
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3817
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3818
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3819
    { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3820
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3821
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3822
    { "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" },
3823
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3824
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3825
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3826
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3827
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3828
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3829
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3830
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3831
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3832
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3833
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3834
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3835
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3836
    { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3837
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3838
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3839
    { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3840
    { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3841
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3842
      "use same video quality as source (implies VBR)" },
3843
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3844
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3845
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3846
      "deinterlace pictures" },
3847
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3848
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3849
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3850
#ifdef CONFIG_VHOOK
3851
    { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3852
#endif
3853
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3854
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3855
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3856
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3857
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3858
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3859
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3860

    
3861
    /* audio options */
3862
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3863
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3864
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3865
    { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3866
    { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3867
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3868
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3869
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3870
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3871
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3872
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3873

    
3874
    /* subtitle options */
3875
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3876
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3877
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3878
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3879

    
3880
    /* grab options */
3881
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3882
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3883
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3884

    
3885
    /* muxer options */
3886
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3887
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3888

    
3889
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3890
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3891
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3892

    
3893
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3894
    { NULL, },
3895
};
3896

    
3897
int main(int argc, char **argv)
3898
{
3899
    int i;
3900
    int64_t ti;
3901

    
3902
    avcodec_register_all();
3903
    avdevice_register_all();
3904
    av_register_all();
3905

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

    
3912
    show_banner(program_name, program_birth_year);
3913
    if (argc <= 1) {
3914
        show_help();
3915
        exit(1);
3916
    }
3917

    
3918
    /* parse options */
3919
    parse_options(argc, argv, options, opt_output_file);
3920

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

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

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

    
3940
    return av_exit();
3941
}