Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ a0b3bcd9

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 "libavformat/avformat.h"
31
#include "libavdevice/avdevice.h"
32
#include "libswscale/swscale.h"
33
#include "libavformat/framehook.h"
34
#include "libavcodec/opt.h"
35
#include "libavutil/fifo.h"
36
#include "libavutil/avstring.h"
37
#include "libavformat/os_support.h"
38

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

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

    
58
#include "version.h"
59
#include "cmdutils.h"
60

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

    
64
#undef exit
65

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

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

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

    
83
static const OptionDef options[];
84

    
85
#define MAX_FILES 20
86

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

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

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

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

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

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

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

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

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

    
188
static int rate_emu = 0;
189

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

    
193
static int audio_volume = 256;
194

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

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

    
211
static unsigned int sws_flags = SWS_BICUBIC;
212

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

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

    
225
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
226

    
227
struct AVInputStream;
228

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

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

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

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

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

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

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

    
287
#ifdef HAVE_TERMIOS_H
288

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

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

    
300
static volatile sig_atomic_t received_sigterm = 0;
301

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

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

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

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

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

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

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

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

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

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

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

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

    
396
    av_free_static();
397

    
398
    av_free(intra_matrix);
399
    av_free(inter_matrix);
400

    
401
    if (vstats_file)
402
        fclose(vstats_file);
403
    av_free(vstats_filename);
404

    
405
    av_free(opt_names);
406

    
407
    av_free(video_codec_name);
408
    av_free(audio_codec_name);
409
    av_free(subtitle_codec_name);
410

    
411
    av_free(video_standard);
412

    
413
#ifdef CONFIG_POWERPC_PERF
414
    extern void powerpc_display_perf_report(void);
415
    powerpc_display_perf_report();
416
#endif /* CONFIG_POWERPC_PERF */
417

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

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

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

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

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

    
450
    av_close_input_file(ic);
451
    return 0;
452
}
453

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

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

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

    
481
        bsfc= bsfc->next;
482
    }
483

    
484
    ret= av_interleaved_write_frame(s, pkt);
485
    if(ret < 0){
486
        print_error("av_interleaved_write_frame()", ret);
487
        av_exit(1);
488
    }
489
}
490

    
491
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
492

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

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

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

    
515
    if (enc->channels != dec->channels)
516
        ost->audio_resample = 1;
517

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

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

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

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

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

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

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

    
593
        frame_bytes = enc->frame_size * 2 * enc->channels;
594

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

    
599
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
600

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

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

    
618
        ost->sync_opts += size_out / (2 * enc->channels);
619

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

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

    
666
    dec = ist->st->codec;
667

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

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

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

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

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

    
700
    if (picture != picture2)
701
        *picture = *picture2;
702
    *bufp = buf;
703
}
704

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

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

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

    
725
    enc = ost->st->codec;
726

    
727
    if (!subtitle_out) {
728
        subtitle_out = av_malloc(subtitle_out_max_size);
729
    }
730

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

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

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

    
760
static int bit_buffer_size= 1024*256;
761
static uint8_t *bit_buffer= NULL;
762

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

    
774
    avcodec_get_frame_defaults(&picture_crop_temp);
775
    avcodec_get_frame_defaults(&picture_pad_temp);
776

    
777
    enc = ost->st->codec;
778
    dec = ist->st->codec;
779

    
780
    /* by default, we output a single frame */
781
    nb_frames = 1;
782

    
783
    *frame_size = 0;
784

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
997

    
998
    oc = output_files[0];
999

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

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

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

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

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

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

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

    
1079
        fflush(stderr);
1080
    }
1081

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

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

    
1112
    if(ist->next_pts == AV_NOPTS_VALUE)
1113
        ist->next_pts= ist->pts;
1114

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

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

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

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

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

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

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

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

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

    
1244
            ist->frame++;
1245
        }
1246

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

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

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

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

    
1302
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1303
                            continue;
1304

    
1305
                        /* no reencoding needed : output the packet directly */
1306
                        /* force the input stream PTS */
1307

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

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

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

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

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

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

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

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

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

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

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

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

    
1425
    return 0;
1426
 fail_decode:
1427
    return -1;
1428
}
1429

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

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

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

    
1461
    return -1;
1462
}
1463

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1643
        codec = ost->st->codec;
1644
        icodec = ist->st->codec;
1645

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

    
1650
        ost->st->disposition = ist->st->disposition;
1651

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

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

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

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

    
1810
    if (!bit_buffer)
1811
        bit_buffer = av_malloc(bit_buffer_size);
1812
    if (!bit_buffer)
1813
        goto fail;
1814

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

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

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

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

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

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

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

    
1907
        out_file = output_files[out_file_index];
1908
        in_file = input_files[in_file_index];
1909

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

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

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

    
1942
    key = -1;
1943
    timer_start = av_gettime();
1944

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

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

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

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

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

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

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

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

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

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

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

    
2053
            av_free_packet(&pkt);
2054
            goto redo;
2055
        }
2056

    
2057
    discard_packet:
2058
        av_free_packet(&pkt);
2059

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

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

    
2072
    term_exit();
2073

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

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

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

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

    
2100
    /* finished ! */
2101

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

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

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

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

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

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

    
2180
extern int ffm_nopts;
2181

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

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

    
2207
//    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));
2208

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

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

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

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

    
2229
static int opt_me_threshold(const char *opt, const char *arg)
2230
{
2231
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2232
    return 0;
2233
}
2234

    
2235
static int opt_verbose(const char *opt, const char *arg)
2236
{
2237
    verbose = parse_number_or_die(opt, arg, OPT_INT64, AV_LOG_QUIET, AV_LOG_DEBUG);
2238
    av_log_set_level(verbose);
2239
    return 0;
2240
}
2241

    
2242
static void opt_frame_rate(const char *arg)
2243
{
2244
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2245
        fprintf(stderr, "Incorrect frame rate\n");
2246
        av_exit(1);
2247
    }
2248
}
2249

    
2250
static int opt_bitrate(const char *opt, const char *arg)
2251
{
2252
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2253

    
2254
    opt_default(opt, arg);
2255

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

    
2259
    return 0;
2260
}
2261

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

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

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

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

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

    
2346

    
2347
#define SCALEBITS 10
2348
#define ONE_HALF  (1 << (SCALEBITS - 1))
2349
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2350

    
2351
#define RGB_TO_Y(r, g, b) \
2352
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2353
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2354

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

    
2359
#define RGB_TO_V(r1, g1, b1, shift)\
2360
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2361
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2362

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

    
2369
    r = (rgb >> 16);
2370
    g = ((rgb >> 8) & 255);
2371
    b = (rgb & 255);
2372

    
2373
    padcolor[0] = RGB_TO_Y(r,g,b);
2374
    padcolor[1] = RGB_TO_U(r,g,b,0);
2375
    padcolor[2] = RGB_TO_V(r,g,b,0);
2376
}
2377

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

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

    
2404

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

    
2418

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

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

    
2442
static void opt_frame_pix_fmt(const char *arg)
2443
{
2444
    if (strcmp(arg, "list"))
2445
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2446
    else {
2447
        list_pix_fmts();
2448
        av_exit(0);
2449
    }
2450
}
2451

    
2452
static void opt_frame_aspect_ratio(const char *arg)
2453
{
2454
    int x = 0, y = 0;
2455
    double ar = 0;
2456
    const char *p;
2457
    char *end;
2458

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

    
2469
    if (!ar) {
2470
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2471
        av_exit(1);
2472
    }
2473
    frame_aspect_ratio = ar;
2474
}
2475

    
2476
static void opt_qscale(const char *arg)
2477
{
2478
    video_qscale = atof(arg);
2479
    if (video_qscale <= 0 ||
2480
        video_qscale > 255) {
2481
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2482
        av_exit(1);
2483
    }
2484
}
2485

    
2486
static void opt_qdiff(const char *arg)
2487
{
2488
    video_qdiff = atoi(arg);
2489
    if (video_qdiff < 0 ||
2490
        video_qdiff > 31) {
2491
        fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2492
        av_exit(1);
2493
    }
2494
}
2495

    
2496
static void opt_strict(const char *arg)
2497
{
2498
    strict= atoi(arg);
2499
}
2500

    
2501
static void opt_top_field_first(const char *arg)
2502
{
2503
    top_field_first= atoi(arg);
2504
}
2505

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

    
2515
static int opt_audio_rate(const char *opt, const char *arg)
2516
{
2517
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2518
    return 0;
2519
}
2520

    
2521
static int opt_audio_channels(const char *opt, const char *arg)
2522
{
2523
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2524
    return 0;
2525
}
2526

    
2527
static void opt_video_channel(const char *arg)
2528
{
2529
    video_channel = strtol(arg, NULL, 0);
2530
}
2531

    
2532
static void opt_video_standard(const char *arg)
2533
{
2534
    video_standard = av_strdup(arg);
2535
}
2536

    
2537
static void opt_codec(int *pstream_copy, char **pcodec_name,
2538
                      int codec_type, const char *arg)
2539
{
2540
    av_freep(pcodec_name);
2541
    if (!strcmp(arg, "copy")) {
2542
        *pstream_copy = 1;
2543
    } else {
2544
        *pcodec_name = av_strdup(arg);
2545
    }
2546
}
2547

    
2548
static void opt_audio_codec(const char *arg)
2549
{
2550
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2551
}
2552

    
2553
static void opt_audio_tag(const char *arg)
2554
{
2555
    char *tail;
2556
    audio_codec_tag= strtol(arg, &tail, 0);
2557

    
2558
    if(!tail || *tail)
2559
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2560
}
2561

    
2562
static void opt_video_tag(const char *arg)
2563
{
2564
    char *tail;
2565
    video_codec_tag= strtol(arg, &tail, 0);
2566

    
2567
    if(!tail || *tail)
2568
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2569
}
2570

    
2571
#ifdef CONFIG_VHOOK
2572
static void add_frame_hooker(const char *arg)
2573
{
2574
    int argc = 0;
2575
    char *argv[64];
2576
    int i;
2577
    char *args = av_strdup(arg);
2578

    
2579
    using_vhook = 1;
2580

    
2581
    argv[0] = strtok(args, " ");
2582
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2583
    }
2584

    
2585
    i = frame_hook_add(argc, argv);
2586

    
2587
    if (i != 0) {
2588
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2589
        av_exit(1);
2590
    }
2591
}
2592
#endif
2593

    
2594
static void opt_video_codec(const char *arg)
2595
{
2596
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2597
}
2598

    
2599
static void opt_subtitle_codec(const char *arg)
2600
{
2601
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2602
}
2603

    
2604
static void opt_map(const char *arg)
2605
{
2606
    AVStreamMap *m;
2607
    char *p;
2608

    
2609
    m = &stream_maps[nb_stream_maps++];
2610

    
2611
    m->file_index = strtol(arg, &p, 0);
2612
    if (*p)
2613
        p++;
2614

    
2615
    m->stream_index = strtol(p, &p, 0);
2616
    if (*p) {
2617
        p++;
2618
        m->sync_file_index = strtol(p, &p, 0);
2619
        if (*p)
2620
            p++;
2621
        m->sync_stream_index = strtol(p, &p, 0);
2622
    } else {
2623
        m->sync_file_index = m->file_index;
2624
        m->sync_stream_index = m->stream_index;
2625
    }
2626
}
2627

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

    
2633
    m = &meta_data_maps[nb_meta_data_maps++];
2634

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

    
2639
    m->in_file = strtol(p, &p, 0);
2640
}
2641

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

    
2648
static int opt_start_time(const char *opt, const char *arg)
2649
{
2650
    start_time = parse_time_or_die(opt, arg, 1);
2651
    return 0;
2652
}
2653

    
2654
static int opt_rec_timestamp(const char *opt, const char *arg)
2655
{
2656
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2657
    return 0;
2658
}
2659

    
2660
static int opt_input_ts_offset(const char *opt, const char *arg)
2661
{
2662
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2663
    return 0;
2664
}
2665

    
2666
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2667
{
2668
    const char *codec_string = encoder ? "encoder" : "decoder";
2669
    AVCodec *codec;
2670

    
2671
    if(!name)
2672
        return CODEC_ID_NONE;
2673
    codec = encoder ?
2674
        avcodec_find_encoder_by_name(name) :
2675
        avcodec_find_decoder_by_name(name);
2676
    if(!codec) {
2677
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2678
        av_exit(1);
2679
    }
2680
    if(codec->type != type) {
2681
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2682
        av_exit(1);
2683
    }
2684
    return codec->id;
2685
}
2686

    
2687
static void opt_input_file(const char *filename)
2688
{
2689
    AVFormatContext *ic;
2690
    AVFormatParameters params, *ap = &params;
2691
    int err, i, ret, rfps, rfps_base;
2692
    int64_t timestamp;
2693

    
2694
    if (!strcmp(filename, "-"))
2695
        filename = "pipe:";
2696

    
2697
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2698
                   !strcmp( filename, "/dev/stdin" );
2699

    
2700
    /* get default parameters from command line */
2701
    ic = av_alloc_format_context();
2702

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

    
2719
    for(i=0; i<opt_name_count; i++){
2720
        char buf[256];
2721
        const AVOption *opt;
2722
        const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2723
        if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2724
            av_set_string(ic, opt_names[i], str);
2725
    }
2726

    
2727
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2728
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2729
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2730

    
2731
    /* open the input file with generic libav function */
2732
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2733
    if (err < 0) {
2734
        print_error(filename, err);
2735
        av_exit(1);
2736
    }
2737
    if(opt_programid) {
2738
        int i;
2739
        for(i=0; i<ic->nb_programs; i++)
2740
            if(ic->programs[i]->id != opt_programid)
2741
                ic->programs[i]->discard = AVDISCARD_ALL;
2742
    }
2743

    
2744
    ic->loop_input = loop_input;
2745

    
2746
    /* If not enough info to get the stream parameters, we decode the
2747
       first frames to get it. (used in mpeg case for example) */
2748
    ret = av_find_stream_info(ic);
2749
    if (ret < 0 && verbose >= 0) {
2750
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2751
        av_exit(1);
2752
    }
2753

    
2754
    timestamp = start_time;
2755
    /* add the stream start time */
2756
    if (ic->start_time != AV_NOPTS_VALUE)
2757
        timestamp += ic->start_time;
2758

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

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

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

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

    
2816
                    (float)rfps / rfps_base, rfps, rfps_base);
2817
            }
2818
            /* update the current frame rate to match the stream frame rate */
2819
            frame_rate.num = rfps;
2820
            frame_rate.den = rfps_base;
2821

    
2822
            enc->rate_emu = rate_emu;
2823
            if(video_disable)
2824
                ic->streams[i]->discard= AVDISCARD_ALL;
2825
            else if(video_discard)
2826
                ic->streams[i]->discard= video_discard;
2827
            break;
2828
        case CODEC_TYPE_DATA:
2829
            break;
2830
        case CODEC_TYPE_SUBTITLE:
2831
            if(subtitle_disable)
2832
                ic->streams[i]->discard = AVDISCARD_ALL;
2833
            break;
2834
        case CODEC_TYPE_ATTACHMENT:
2835
        case CODEC_TYPE_UNKNOWN:
2836
            break;
2837
        default:
2838
            abort();
2839
        }
2840
    }
2841

    
2842
    input_files[nb_input_files] = ic;
2843
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2844
    /* dump the file content */
2845
    if (verbose >= 0)
2846
        dump_format(ic, nb_input_files, filename, 0);
2847

    
2848
    nb_input_files++;
2849
    file_iformat = NULL;
2850
    file_oformat = NULL;
2851

    
2852
    video_channel = 0;
2853

    
2854
    rate_emu = 0;
2855
    av_freep(&video_codec_name);
2856
    av_freep(&audio_codec_name);
2857
    av_freep(&subtitle_codec_name);
2858
}
2859

    
2860
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2861
                                         int *has_subtitle_ptr)
2862
{
2863
    int has_video, has_audio, has_subtitle, i, j;
2864
    AVFormatContext *ic;
2865

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

    
2897
static void new_video_stream(AVFormatContext *oc)
2898
{
2899
    AVStream *st;
2900
    AVCodecContext *video_enc;
2901
    int codec_id;
2902

    
2903
    st = av_new_stream(oc, oc->nb_streams);
2904
    if (!st) {
2905
        fprintf(stderr, "Could not alloc stream\n");
2906
        av_exit(1);
2907
    }
2908
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2909
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2910
    video_bitstream_filters= NULL;
2911

    
2912
    if(thread_count>1)
2913
        avcodec_thread_init(st->codec, thread_count);
2914

    
2915
    video_enc = st->codec;
2916

    
2917
    if(video_codec_tag)
2918
        video_enc->codec_tag= video_codec_tag;
2919

    
2920
    if(   (video_global_header&1)
2921
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2922
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2923
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2924
    }
2925
    if(video_global_header&2){
2926
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2927
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2928
    }
2929

    
2930
    if (video_stream_copy) {
2931
        st->stream_copy = 1;
2932
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2933
    } else {
2934
        const char *p;
2935
        int i;
2936
        AVCodec *codec;
2937
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2938

    
2939
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2940
        if (video_codec_name)
2941
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2942

    
2943
        video_enc->codec_id = codec_id;
2944
        codec = avcodec_find_encoder(codec_id);
2945

    
2946
        for(i=0; i<opt_name_count; i++){
2947
            char buf[256];
2948
            const AVOption *opt;
2949
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2950
            if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2951
                av_set_string(video_enc, opt_names[i], str);
2952
        }
2953

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

    
2972
        video_enc->width = frame_width + frame_padright + frame_padleft;
2973
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
2974
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2975
        video_enc->pix_fmt = frame_pix_fmt;
2976

    
2977
        if(codec && codec->pix_fmts){
2978
            const enum PixelFormat *p= codec->pix_fmts;
2979
            for(; *p!=-1; p++){
2980
                if(*p == video_enc->pix_fmt)
2981
                    break;
2982
            }
2983
            if(*p == -1)
2984
                video_enc->pix_fmt = codec->pix_fmts[0];
2985
        }
2986

    
2987
        if (intra_only)
2988
            video_enc->gop_size = 0;
2989
        if (video_qscale || same_quality) {
2990
            video_enc->flags |= CODEC_FLAG_QSCALE;
2991
            video_enc->global_quality=
2992
                st->quality = FF_QP2LAMBDA * video_qscale;
2993
        }
2994

    
2995
        if(intra_matrix)
2996
            video_enc->intra_matrix = intra_matrix;
2997
        if(inter_matrix)
2998
            video_enc->inter_matrix = inter_matrix;
2999

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

    
3033
        if (do_psnr)
3034
            video_enc->flags|= CODEC_FLAG_PSNR;
3035

    
3036
        /* two pass mode */
3037
        if (do_pass) {
3038
            if (do_pass == 1) {
3039
                video_enc->flags |= CODEC_FLAG_PASS1;
3040
            } else {
3041
                video_enc->flags |= CODEC_FLAG_PASS2;
3042
            }
3043
        }
3044
    }
3045

    
3046
    /* reset some key parameters */
3047
    video_disable = 0;
3048
    av_freep(&video_codec_name);
3049
    video_stream_copy = 0;
3050
}
3051

    
3052
static void new_audio_stream(AVFormatContext *oc)
3053
{
3054
    AVStream *st;
3055
    AVCodecContext *audio_enc;
3056
    int codec_id, i;
3057

    
3058
    st = av_new_stream(oc, oc->nb_streams);
3059
    if (!st) {
3060
        fprintf(stderr, "Could not alloc stream\n");
3061
        av_exit(1);
3062
    }
3063
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3064

    
3065
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3066
    audio_bitstream_filters= NULL;
3067

    
3068
    if(thread_count>1)
3069
        avcodec_thread_init(st->codec, thread_count);
3070

    
3071
    audio_enc = st->codec;
3072
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3073
    audio_enc->strict_std_compliance = strict;
3074

    
3075
    if(audio_codec_tag)
3076
        audio_enc->codec_tag= audio_codec_tag;
3077

    
3078
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3079
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3080
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3081
    }
3082
    if (audio_stream_copy) {
3083
        st->stream_copy = 1;
3084
        audio_enc->channels = audio_channels;
3085
    } else {
3086
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3087

    
3088
        for(i=0; i<opt_name_count; i++){
3089
            char buf[256];
3090
            const AVOption *opt;
3091
            const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3092
            if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3093
                av_set_string(audio_enc, opt_names[i], str);
3094
        }
3095

    
3096
        if (audio_codec_name)
3097
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3098
        audio_enc->codec_id = codec_id;
3099

    
3100
        if (audio_qscale > QSCALE_NONE) {
3101
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3102
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3103
        }
3104
        audio_enc->thread_count = thread_count;
3105
        audio_enc->channels = audio_channels;
3106
    }
3107
    audio_enc->sample_rate = audio_sample_rate;
3108
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3109
    if (audio_language) {
3110
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3111
        av_free(audio_language);
3112
        audio_language = NULL;
3113
    }
3114

    
3115
    /* reset some key parameters */
3116
    audio_disable = 0;
3117
    av_freep(&audio_codec_name);
3118
    audio_stream_copy = 0;
3119
}
3120

    
3121
static void new_subtitle_stream(AVFormatContext *oc)
3122
{
3123
    AVStream *st;
3124
    AVCodecContext *subtitle_enc;
3125
    int i;
3126

    
3127
    st = av_new_stream(oc, oc->nb_streams);
3128
    if (!st) {
3129
        fprintf(stderr, "Could not alloc stream\n");
3130
        av_exit(1);
3131
    }
3132
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3133

    
3134
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3135
    subtitle_bitstream_filters= NULL;
3136

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

    
3152
    if (subtitle_language) {
3153
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3154
        av_free(subtitle_language);
3155
        subtitle_language = NULL;
3156
    }
3157

    
3158
    subtitle_disable = 0;
3159
    av_freep(&subtitle_codec_name);
3160
    subtitle_stream_copy = 0;
3161
}
3162

    
3163
static void opt_new_audio_stream(void)
3164
{
3165
    AVFormatContext *oc;
3166
    if (nb_output_files <= 0) {
3167
        fprintf(stderr, "At least one output file must be specified\n");
3168
        av_exit(1);
3169
    }
3170
    oc = output_files[nb_output_files - 1];
3171
    new_audio_stream(oc);
3172
}
3173

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

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

    
3196
static void opt_output_file(const char *filename)
3197
{
3198
    AVFormatContext *oc;
3199
    int use_video, use_audio, use_subtitle;
3200
    int input_has_video, input_has_audio, input_has_subtitle, i;
3201
    AVFormatParameters params, *ap = &params;
3202

    
3203
    if (!strcmp(filename, "-"))
3204
        filename = "pipe:";
3205

    
3206
    oc = av_alloc_format_context();
3207

    
3208
    if (!file_oformat) {
3209
        file_oformat = guess_format(NULL, filename, NULL);
3210
        if (!file_oformat) {
3211
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3212
                    filename);
3213
            av_exit(1);
3214
        }
3215
    }
3216

    
3217
    oc->oformat = file_oformat;
3218
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3219

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

    
3233
        /* disable if no corresponding type found and at least one
3234
           input file */
3235
        if (nb_input_files > 0) {
3236
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3237
                                         &input_has_subtitle);
3238
            if (!input_has_video)
3239
                use_video = 0;
3240
            if (!input_has_audio)
3241
                use_audio = 0;
3242
            if (!input_has_subtitle)
3243
                use_subtitle = 0;
3244
        }
3245

    
3246
        /* manual disable */
3247
        if (audio_disable) {
3248
            use_audio = 0;
3249
        }
3250
        if (video_disable) {
3251
            use_video = 0;
3252
        }
3253
        if (subtitle_disable) {
3254
            use_subtitle = 0;
3255
        }
3256

    
3257
        if (use_video) {
3258
            new_video_stream(oc);
3259
        }
3260

    
3261
        if (use_audio) {
3262
            new_audio_stream(oc);
3263
        }
3264

    
3265
        if (use_subtitle) {
3266
            new_subtitle_stream(oc);
3267
        }
3268

    
3269
        oc->timestamp = rec_timestamp;
3270

    
3271
        if (str_title)
3272
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3273
        if (str_author)
3274
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3275
        if (str_copyright)
3276
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3277
        if (str_comment)
3278
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3279
        if (str_album)
3280
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3281
        if (str_genre)
3282
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3283
    }
3284

    
3285
    output_files[nb_output_files++] = oc;
3286

    
3287
    /* check filename in case of an image number is expected */
3288
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3289
        if (!av_filename_number_test(oc->filename)) {
3290
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3291
            av_exit(1);
3292
        }
3293
    }
3294

    
3295
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3296
        /* test if it already exists to avoid loosing precious files */
3297
        if (!file_overwrite &&
3298
            (strchr(filename, ':') == NULL ||
3299
             filename[1] == ':' ||
3300
             av_strstart(filename, "file:", NULL))) {
3301
            if (url_exist(filename)) {
3302
                int c;
3303

    
3304
                if ( !using_stdin ) {
3305
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3306
                    fflush(stderr);
3307
                    c = getchar();
3308
                    if (toupper(c) != 'Y') {
3309
                        fprintf(stderr, "Not overwriting - exiting\n");
3310
                        av_exit(1);
3311
                    }
3312
                                }
3313
                                else {
3314
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3315
                    av_exit(1);
3316
                                }
3317
            }
3318
        }
3319

    
3320
        /* open the file */
3321
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3322
            fprintf(stderr, "Could not open '%s'\n", filename);
3323
            av_exit(1);
3324
        }
3325
    }
3326

    
3327
    memset(ap, 0, sizeof(*ap));
3328
    if (av_set_parameters(oc, ap) < 0) {
3329
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3330
                oc->filename);
3331
        av_exit(1);
3332
    }
3333

    
3334
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3335
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3336
    oc->loop_output = loop_output;
3337

    
3338
    for(i=0; i<opt_name_count; i++){
3339
        char buf[256];
3340
        const AVOption *opt;
3341
        const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3342
        if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3343
            av_set_string(oc, opt_names[i], str);
3344
    }
3345

    
3346
    /* reset some options */
3347
    file_oformat = NULL;
3348
    file_iformat = NULL;
3349
}
3350

    
3351
/* same option as mencoder */
3352
static void opt_pass(const char *pass_str)
3353
{
3354
    int pass;
3355
    pass = atoi(pass_str);
3356
    if (pass != 1 && pass != 2) {
3357
        fprintf(stderr, "pass number can be only 1 or 2\n");
3358
        av_exit(1);
3359
    }
3360
    do_pass = pass;
3361
}
3362

    
3363
static int64_t getutime(void)
3364
{
3365
#ifdef HAVE_GETRUSAGE
3366
    struct rusage rusage;
3367

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

    
3381
static void opt_show_formats(void)
3382
{
3383
    AVInputFormat *ifmt=NULL;
3384
    AVOutputFormat *ofmt=NULL;
3385
    URLProtocol *up=NULL;
3386
    AVCodec *p=NULL, *p2;
3387
    AVBitStreamFilter *bsf=NULL;
3388
    const char *last_name;
3389

    
3390
    printf("File formats:\n");
3391
    last_name= "000";
3392
    for(;;){
3393
        int decode=0;
3394
        int encode=0;
3395
        const char *name=NULL;
3396
        const char *long_name=NULL;
3397

    
3398
        while((ofmt= av_oformat_next(ofmt))) {
3399
            if((name == NULL || strcmp(ofmt->name, name)<0) &&
3400
                strcmp(ofmt->name, last_name)>0){
3401
                name= ofmt->name;
3402
                long_name= ofmt->long_name;
3403
                encode=1;
3404
            }
3405
        }
3406
        while((ifmt= av_iformat_next(ifmt))) {
3407
            if((name == NULL || strcmp(ifmt->name, name)<0) &&
3408
                strcmp(ifmt->name, last_name)>0){
3409
                name= ifmt->name;
3410
                long_name= ifmt->long_name;
3411
                encode=0;
3412
            }
3413
            if(name && strcmp(ifmt->name, name)==0)
3414
                decode=1;
3415
        }
3416
        if(name==NULL)
3417
            break;
3418
        last_name= name;
3419

    
3420
        printf(
3421
            " %s%s %-15s %s\n",
3422
            decode ? "D":" ",
3423
            encode ? "E":" ",
3424
            name,
3425
            long_name ? long_name:" ");
3426
    }
3427
    printf("\n");
3428

    
3429
    printf("Codecs:\n");
3430
    last_name= "000";
3431
    for(;;){
3432
        int decode=0;
3433
        int encode=0;
3434
        int cap=0;
3435
        const char *type_str;
3436

    
3437
        p2=NULL;
3438
        while((p= av_codec_next(p))) {
3439
            if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3440
                strcmp(p->name, last_name)>0){
3441
                p2= p;
3442
                decode= encode= cap=0;
3443
            }
3444
            if(p2 && strcmp(p->name, p2->name)==0){
3445
                if(p->decode) decode=1;
3446
                if(p->encode) encode=1;
3447
                cap |= p->capabilities;
3448
            }
3449
        }
3450
        if(p2==NULL)
3451
            break;
3452
        last_name= p2->name;
3453

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

    
3484
    printf("Bitstream filters:\n");
3485
    while((bsf = av_bitstream_filter_next(bsf)))
3486
        printf(" %s", bsf->name);
3487
    printf("\n");
3488

    
3489
    printf("Supported file protocols:\n");
3490
    while((up = av_protocol_next(up)))
3491
        printf(" %s:", up->name);
3492
    printf("\n");
3493

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

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

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

    
3527
static void opt_intra_matrix(const char *arg)
3528
{
3529
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3530
    parse_matrix_coeffs(intra_matrix, arg);
3531
}
3532

    
3533
/**
3534
 * Trivial log callback.
3535
 * Only suitable for show_help and similar since it lacks prefix handling.
3536
 */
3537
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3538
{
3539
    vfprintf(stdout, fmt, vl);
3540
}
3541

    
3542
static void show_help(void)
3543
{
3544
    av_log_set_callback(log_callback_help);
3545
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3546
           "Hyper fast Audio and Video encoder\n");
3547
    printf("\n");
3548
    show_help_options(options, "Main options:\n",
3549
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3550
    show_help_options(options, "\nVideo options:\n",
3551
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3552
                      OPT_VIDEO);
3553
    show_help_options(options, "\nAdvanced Video options:\n",
3554
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3555
                      OPT_VIDEO | OPT_EXPERT);
3556
    show_help_options(options, "\nAudio options:\n",
3557
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3558
                      OPT_AUDIO);
3559
    show_help_options(options, "\nAdvanced Audio options:\n",
3560
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3561
                      OPT_AUDIO | OPT_EXPERT);
3562
    show_help_options(options, "\nSubtitle options:\n",
3563
                      OPT_SUBTITLE | OPT_GRAB,
3564
                      OPT_SUBTITLE);
3565
    show_help_options(options, "\nAudio/Video grab options:\n",
3566
                      OPT_GRAB,
3567
                      OPT_GRAB);
3568
    show_help_options(options, "\nAdvanced options:\n",
3569
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3570
                      OPT_EXPERT);
3571
    av_opt_show(avctx_opts[0], NULL);
3572
    av_opt_show(avformat_opts, NULL);
3573
    av_opt_show(sws_opts, NULL);
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
        av_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
        av_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
        av_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_version(void)
3760
{
3761
    show_version(program_name);
3762
    av_exit(0);
3763
}
3764

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

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

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

    
3868
    /* subtitle options */
3869
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3870
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3871
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3872
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3873

    
3874
    /* grab options */
3875
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3876
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3877
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3878

    
3879
    /* muxer options */
3880
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3881
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3882

    
3883
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3884
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3885
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3886

    
3887
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3888
    { NULL, },
3889
};
3890

    
3891
int main(int argc, char **argv)
3892
{
3893
    int i;
3894
    int64_t ti;
3895

    
3896
    avcodec_register_all();
3897
    avdevice_register_all();
3898
    av_register_all();
3899

    
3900
    for(i=0; i<CODEC_TYPE_NB; i++){
3901
        avctx_opts[i]= avcodec_alloc_context2(i);
3902
    }
3903
    avformat_opts = av_alloc_format_context();
3904
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3905

    
3906
    show_banner(program_name, program_birth_year);
3907
    if (argc <= 1) {
3908
        show_help();
3909
        av_exit(1);
3910
    }
3911

    
3912
    /* parse options */
3913
    parse_options(argc, argv, options, opt_output_file);
3914

    
3915
    /* file converter / grab */
3916
    if (nb_output_files <= 0) {
3917
        fprintf(stderr, "Must supply at least one output file\n");
3918
        av_exit(1);
3919
    }
3920

    
3921
    if (nb_input_files == 0) {
3922
        fprintf(stderr, "Must supply at least one input file\n");
3923
        av_exit(1);
3924
    }
3925

    
3926
    ti = getutime();
3927
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3928
              stream_maps, nb_stream_maps);
3929
    ti = getutime() - ti;
3930
    if (do_benchmark) {
3931
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3932
    }
3933

    
3934
    return av_exit(0);
3935
}