Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ f44fd374

History | View | Annotate | Download (138 KB)

1
/*
2
 * FFmpeg main
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
#include "config.h"
23
#include <ctype.h>
24
#include <string.h>
25
#include <math.h>
26
#include <stdlib.h>
27
#include <errno.h>
28
#include <signal.h>
29
#include <limits.h>
30
#include "libavformat/avformat.h"
31
#include "libavdevice/avdevice.h"
32
#include "libswscale/swscale.h"
33
#include "libavformat/framehook.h"
34
#include "libavcodec/opt.h"
35
#include "libavcodec/audioconvert.h"
36
#include "libavutil/fifo.h"
37
#include "libavutil/avstring.h"
38
#include "libavformat/os_support.h"
39

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

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

    
59
#include "cmdutils.h"
60

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

    
64
#undef exit
65

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

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

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

    
83
static const OptionDef options[];
84

    
85
#define MAX_FILES 20
86

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

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

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

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

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

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

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

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

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

    
188
static int rate_emu = 0;
189

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

    
193
static int audio_volume = 256;
194

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

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

    
211
static unsigned int sws_flags = SWS_BICUBIC;
212

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

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

    
225
#define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
226

    
227
struct AVInputStream;
228

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

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

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

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

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

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

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

    
289
#ifdef HAVE_TERMIOS_H
290

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

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

    
302
static volatile sig_atomic_t received_sigterm = 0;
303

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

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

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

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

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

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

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

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

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

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

    
378
static int av_exit(int ret)
379
{
380
    int i;
381

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

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

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

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

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

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

    
464
    if (!nopts)
465
        s->timestamp = av_gettime();
466

    
467
    av_close_input_file(ic);
468
    return 0;
469
}
470

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

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

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

    
498
        bsfc= bsfc->next;
499
    }
500

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

    
508
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
509

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

    
521
    int size_out, frame_bytes, ret;
522
    AVCodecContext *enc= ost->st->codec;
523
    AVCodecContext *dec= ist->st->codec;
524

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

    
533
    if (enc->channels != dec->channels)
534
        ost->audio_resample = 1;
535

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

    
547
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
548
    if (dec->sample_fmt!=enc->sample_fmt &&
549
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
550
        if (!audio_out2)
551
            audio_out2 = av_malloc(audio_out_size);
552
        if (!audio_out2)
553
            av_exit(1);
554
        if (ost->reformat_ctx)
555
            av_audio_convert_free(ost->reformat_ctx);
556
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
557
                                                   dec->sample_fmt, 1, NULL, 0);
558
        if (!ost->reformat_ctx) {
559
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
560
                avcodec_get_sample_fmt_name(dec->sample_fmt),
561
                avcodec_get_sample_fmt_name(enc->sample_fmt));
562
            av_exit(1);
563
        }
564
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
565
    }
566

    
567
    if(audio_sync_method){
568
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
569
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
570
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
571
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
572

    
573
        //FIXME resample delay
574
        if(fabs(delta) > 50){
575
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
576
                if(byte_delta < 0){
577
                    byte_delta= FFMAX(byte_delta, -size);
578
                    size += byte_delta;
579
                    buf  -= byte_delta;
580
                    if(verbose > 2)
581
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
582
                    if(!size)
583
                        return;
584
                    ist->is_start=0;
585
                }else{
586
                    static uint8_t *input_tmp= NULL;
587
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
588

    
589
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
590
                        ist->is_start=0;
591
                    else
592
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
593

    
594
                    memset(input_tmp, 0, byte_delta);
595
                    memcpy(input_tmp + byte_delta, buf, size);
596
                    buf= input_tmp;
597
                    size += byte_delta;
598
                    if(verbose > 2)
599
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
600
                }
601
            }else if(audio_sync_method>1){
602
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
603
                assert(ost->audio_resample);
604
                if(verbose > 2)
605
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
606
//                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));
607
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
608
            }
609
        }
610
    }else
611
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
612
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
613

    
614
    if (ost->audio_resample) {
615
        buftmp = audio_buf;
616
        size_out = audio_resample(ost->resample,
617
                                  (short *)buftmp, (short *)buf,
618
                                  size / (ist->st->codec->channels * 2));
619
        size_out = size_out * enc->channels * 2;
620
    } else {
621
        buftmp = buf;
622
        size_out = size;
623
    }
624

    
625
    if (dec->sample_fmt!=enc->sample_fmt) {
626
        const void *ibuf[6]= {buftmp};
627
        void *obuf[6]= {audio_out2};
628
        int istride[6]= {av_get_bits_per_sample_format(dec->sample_fmt)/8};
629
        int ostride[6]= {av_get_bits_per_sample_format(enc->sample_fmt)/8};
630
        int len= size_out/istride[0];
631
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
632
            printf("av_audio_convert() failed\n");
633
            return;
634
        }
635
        buftmp = audio_out2;
636
        /* FIXME: existing code assume that size_out equals framesize*channels*2
637
                  remove this legacy cruft */
638
        size_out = len*2;
639
    }
640

    
641
    /* now encode as many frames as possible */
642
    if (enc->frame_size > 1) {
643
        /* output resampled raw samples */
644
        av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out);
645
        av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
646

    
647
        frame_bytes = enc->frame_size * 2 * enc->channels;
648

    
649
        while (av_fifo_size(&ost->fifo) >= frame_bytes) {
650
            AVPacket pkt;
651
            av_init_packet(&pkt);
652

    
653
            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
654

    
655
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
656

    
657
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
658
                                       (short *)audio_buf);
659
            audio_size += ret;
660
            pkt.stream_index= ost->index;
661
            pkt.data= audio_out;
662
            pkt.size= ret;
663
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
664
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
665
            pkt.flags |= PKT_FLAG_KEY;
666
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
667

    
668
            ost->sync_opts += enc->frame_size;
669
        }
670
    } else {
671
        AVPacket pkt;
672
        av_init_packet(&pkt);
673

    
674
        ost->sync_opts += size_out / (2 * enc->channels);
675

    
676
        /* output a pcm frame */
677
        /* XXX: change encoding codec API to avoid this ? */
678
        switch(enc->codec->id) {
679
        case CODEC_ID_PCM_S32LE:
680
        case CODEC_ID_PCM_S32BE:
681
        case CODEC_ID_PCM_U32LE:
682
        case CODEC_ID_PCM_U32BE:
683
        case CODEC_ID_PCM_F32BE:
684
            size_out = size_out << 1;
685
            break;
686
        case CODEC_ID_PCM_S24LE:
687
        case CODEC_ID_PCM_S24BE:
688
        case CODEC_ID_PCM_U24LE:
689
        case CODEC_ID_PCM_U24BE:
690
        case CODEC_ID_PCM_S24DAUD:
691
            size_out = size_out / 2 * 3;
692
            break;
693
        case CODEC_ID_PCM_S16LE:
694
        case CODEC_ID_PCM_S16BE:
695
        case CODEC_ID_PCM_U16LE:
696
        case CODEC_ID_PCM_U16BE:
697
            break;
698
        default:
699
            size_out = size_out >> 1;
700
            break;
701
        }
702
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
703
        ret = avcodec_encode_audio(enc, audio_out, size_out,
704
                                   (short *)buftmp);
705
        audio_size += ret;
706
        pkt.stream_index= ost->index;
707
        pkt.data= audio_out;
708
        pkt.size= ret;
709
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
710
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
711
        pkt.flags |= PKT_FLAG_KEY;
712
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
713
    }
714
}
715

    
716
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
717
{
718
    AVCodecContext *dec;
719
    AVPicture *picture2;
720
    AVPicture picture_tmp;
721
    uint8_t *buf = 0;
722

    
723
    dec = ist->st->codec;
724

    
725
    /* deinterlace : must be done before any resize */
726
    if (do_deinterlace || using_vhook) {
727
        int size;
728

    
729
        /* create temporary picture */
730
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
731
        buf = av_malloc(size);
732
        if (!buf)
733
            return;
734

    
735
        picture2 = &picture_tmp;
736
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
737

    
738
        if (do_deinterlace){
739
            if(avpicture_deinterlace(picture2, picture,
740
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
741
                /* if error, do not deinterlace */
742
                av_free(buf);
743
                buf = NULL;
744
                picture2 = picture;
745
            }
746
        } else {
747
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
748
        }
749
    } else {
750
        picture2 = picture;
751
    }
752

    
753
    if (ENABLE_VHOOK)
754
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
755
                           1000000 * ist->pts / AV_TIME_BASE);
756

    
757
    if (picture != picture2)
758
        *picture = *picture2;
759
    *bufp = buf;
760
}
761

    
762
/* we begin to correct av delay at this threshold */
763
#define AV_DELAY_MAX 0.100
764

    
765
static void do_subtitle_out(AVFormatContext *s,
766
                            AVOutputStream *ost,
767
                            AVInputStream *ist,
768
                            AVSubtitle *sub,
769
                            int64_t pts)
770
{
771
    static uint8_t *subtitle_out = NULL;
772
    int subtitle_out_max_size = 65536;
773
    int subtitle_out_size, nb, i;
774
    AVCodecContext *enc;
775
    AVPacket pkt;
776

    
777
    if (pts == AV_NOPTS_VALUE) {
778
        fprintf(stderr, "Subtitle packets must have a pts\n");
779
        return;
780
    }
781

    
782
    enc = ost->st->codec;
783

    
784
    if (!subtitle_out) {
785
        subtitle_out = av_malloc(subtitle_out_max_size);
786
    }
787

    
788
    /* Note: DVB subtitle need one packet to draw them and one other
789
       packet to clear them */
790
    /* XXX: signal it in the codec context ? */
791
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
792
        nb = 2;
793
    else
794
        nb = 1;
795

    
796
    for(i = 0; i < nb; i++) {
797
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
798
                                                    subtitle_out_max_size, sub);
799

    
800
        av_init_packet(&pkt);
801
        pkt.stream_index = ost->index;
802
        pkt.data = subtitle_out;
803
        pkt.size = subtitle_out_size;
804
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
805
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
806
            /* XXX: the pts correction is handled here. Maybe handling
807
               it in the codec would be better */
808
            if (i == 0)
809
                pkt.pts += 90 * sub->start_display_time;
810
            else
811
                pkt.pts += 90 * sub->end_display_time;
812
        }
813
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
814
    }
815
}
816

    
817
static int bit_buffer_size= 1024*256;
818
static uint8_t *bit_buffer= NULL;
819

    
820
static void do_video_out(AVFormatContext *s,
821
                         AVOutputStream *ost,
822
                         AVInputStream *ist,
823
                         AVFrame *in_picture,
824
                         int *frame_size)
825
{
826
    int nb_frames, i, ret;
827
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
828
    AVFrame picture_crop_temp, picture_pad_temp;
829
    AVCodecContext *enc, *dec;
830

    
831
    avcodec_get_frame_defaults(&picture_crop_temp);
832
    avcodec_get_frame_defaults(&picture_pad_temp);
833

    
834
    enc = ost->st->codec;
835
    dec = ist->st->codec;
836

    
837
    /* by default, we output a single frame */
838
    nb_frames = 1;
839

    
840
    *frame_size = 0;
841

    
842
    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
843
        double vdelta;
844
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
845
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
846
        if (vdelta < -1.1)
847
            nb_frames = 0;
848
        else if (video_sync_method == 2)
849
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
850
        else if (vdelta > 1.1)
851
            nb_frames = lrintf(vdelta);
852
//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);
853
        if (nb_frames == 0){
854
            ++nb_frames_drop;
855
            if (verbose>2)
856
                fprintf(stderr, "*** drop!\n");
857
        }else if (nb_frames > 1) {
858
            nb_frames_dup += nb_frames;
859
            if (verbose>2)
860
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
861
        }
862
    }else
863
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
864

    
865
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
866
    if (nb_frames <= 0)
867
        return;
868

    
869
    if (ost->video_crop) {
870
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
871
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
872
            return;
873
        }
874
        formatted_picture = &picture_crop_temp;
875
    } else {
876
        formatted_picture = in_picture;
877
    }
878

    
879
    final_picture = formatted_picture;
880
    padding_src = formatted_picture;
881
    resampling_dst = &ost->pict_tmp;
882
    if (ost->video_pad) {
883
        final_picture = &ost->pict_tmp;
884
        if (ost->video_resample) {
885
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
886
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
887
                return;
888
            }
889
            resampling_dst = &picture_pad_temp;
890
        }
891
    }
892

    
893
    if (ost->video_resample) {
894
        padding_src = NULL;
895
        final_picture = &ost->pict_tmp;
896
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
897
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
898
    }
899

    
900
    if (ost->video_pad) {
901
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
902
                enc->height, enc->width, enc->pix_fmt,
903
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
904
    }
905

    
906
    /* duplicates frame if needed */
907
    for(i=0;i<nb_frames;i++) {
908
        AVPacket pkt;
909
        av_init_packet(&pkt);
910
        pkt.stream_index= ost->index;
911

    
912
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
913
            /* raw pictures are written as AVPicture structure to
914
               avoid any copies. We support temorarily the older
915
               method. */
916
            AVFrame* old_frame = enc->coded_frame;
917
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
918
            pkt.data= (uint8_t *)final_picture;
919
            pkt.size=  sizeof(AVPicture);
920
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
921
            pkt.flags |= PKT_FLAG_KEY;
922

    
923
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
924
            enc->coded_frame = old_frame;
925
        } else {
926
            AVFrame big_picture;
927

    
928
            big_picture= *final_picture;
929
            /* better than nothing: use input picture interlaced
930
               settings */
931
            big_picture.interlaced_frame = in_picture->interlaced_frame;
932
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
933
                if(top_field_first == -1)
934
                    big_picture.top_field_first = in_picture->top_field_first;
935
                else
936
                    big_picture.top_field_first = top_field_first;
937
            }
938

    
939
            /* handles sameq here. This is not correct because it may
940
               not be a global option */
941
            if (same_quality) {
942
                big_picture.quality = ist->st->quality;
943
            }else
944
                big_picture.quality = ost->st->quality;
945
            if(!me_threshold)
946
                big_picture.pict_type = 0;
947
//            big_picture.pts = AV_NOPTS_VALUE;
948
            big_picture.pts= ost->sync_opts;
949
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
950
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
951
            ret = avcodec_encode_video(enc,
952
                                       bit_buffer, bit_buffer_size,
953
                                       &big_picture);
954
            if (ret == -1) {
955
                fprintf(stderr, "Video encoding failed\n");
956
                av_exit(1);
957
            }
958
            //enc->frame_number = enc->real_pict_num;
959
            if(ret>0){
960
                pkt.data= bit_buffer;
961
                pkt.size= ret;
962
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
963
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
964
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
965
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
966
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
967

    
968
                if(enc->coded_frame->key_frame)
969
                    pkt.flags |= PKT_FLAG_KEY;
970
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
971
                *frame_size = ret;
972
                video_size += ret;
973
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
974
                //        enc->frame_number-1, enc->real_pict_num, ret,
975
                //        enc->pict_type);
976
                /* if two pass, output log */
977
                if (ost->logfile && enc->stats_out) {
978
                    fprintf(ost->logfile, "%s", enc->stats_out);
979
                }
980
            }
981
        }
982
        ost->sync_opts++;
983
        ost->frame_number++;
984
    }
985
}
986

    
987
static double psnr(double d){
988
    return -10.0*log(d)/log(10.0);
989
}
990

    
991
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
992
                           int frame_size)
993
{
994
    AVCodecContext *enc;
995
    int frame_number;
996
    double ti1, bitrate, avg_bitrate;
997

    
998
    /* this is executed just the first time do_video_stats is called */
999
    if (!vstats_file) {
1000
        vstats_file = fopen(vstats_filename, "w");
1001
        if (!vstats_file) {
1002
            perror("fopen");
1003
            av_exit(1);
1004
        }
1005
    }
1006

    
1007
    enc = ost->st->codec;
1008
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1009
        frame_number = ost->frame_number;
1010
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1011
        if (enc->flags&CODEC_FLAG_PSNR)
1012
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1013

    
1014
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1015
        /* compute pts value */
1016
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1017
        if (ti1 < 0.01)
1018
            ti1 = 0.01;
1019

    
1020
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1021
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1022
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1023
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1024
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1025
    }
1026
}
1027

    
1028
static void print_report(AVFormatContext **output_files,
1029
                         AVOutputStream **ost_table, int nb_ostreams,
1030
                         int is_last_report)
1031
{
1032
    char buf[1024];
1033
    AVOutputStream *ost;
1034
    AVFormatContext *oc, *os;
1035
    int64_t total_size;
1036
    AVCodecContext *enc;
1037
    int frame_number, vid, i;
1038
    double bitrate, ti1, pts;
1039
    static int64_t last_time = -1;
1040
    static int qp_histogram[52];
1041

    
1042
    if (!is_last_report) {
1043
        int64_t cur_time;
1044
        /* display the report every 0.5 seconds */
1045
        cur_time = av_gettime();
1046
        if (last_time == -1) {
1047
            last_time = cur_time;
1048
            return;
1049
        }
1050
        if ((cur_time - last_time) < 500000)
1051
            return;
1052
        last_time = cur_time;
1053
    }
1054

    
1055

    
1056
    oc = output_files[0];
1057

    
1058
    total_size = url_fsize(oc->pb);
1059
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1060
        total_size= url_ftell(oc->pb);
1061

    
1062
    buf[0] = '\0';
1063
    ti1 = 1e10;
1064
    vid = 0;
1065
    for(i=0;i<nb_ostreams;i++) {
1066
        ost = ost_table[i];
1067
        os = output_files[ost->file_index];
1068
        enc = ost->st->codec;
1069
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1070
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1071
                     !ost->st->stream_copy ?
1072
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1073
        }
1074
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1075
            float t = (av_gettime()-timer_start) / 1000000.0;
1076

    
1077
            frame_number = ost->frame_number;
1078
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1079
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1080
                     !ost->st->stream_copy ?
1081
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1082
            if(is_last_report)
1083
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1084
            if(qp_hist){
1085
                int j;
1086
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1087
                if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1088
                    qp_histogram[qp]++;
1089
                for(j=0; j<32; j++)
1090
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1091
            }
1092
            if (enc->flags&CODEC_FLAG_PSNR){
1093
                int j;
1094
                double error, error_sum=0;
1095
                double scale, scale_sum=0;
1096
                char type[3]= {'Y','U','V'};
1097
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1098
                for(j=0; j<3; j++){
1099
                    if(is_last_report){
1100
                        error= enc->error[j];
1101
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1102
                    }else{
1103
                        error= enc->coded_frame->error[j];
1104
                        scale= enc->width*enc->height*255.0*255.0;
1105
                    }
1106
                    if(j) scale/=4;
1107
                    error_sum += error;
1108
                    scale_sum += scale;
1109
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1110
                }
1111
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1112
            }
1113
            vid = 1;
1114
        }
1115
        /* compute min output value */
1116
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1117
        if ((pts < ti1) && (pts > 0))
1118
            ti1 = pts;
1119
    }
1120
    if (ti1 < 0.01)
1121
        ti1 = 0.01;
1122

    
1123
    if (verbose || is_last_report) {
1124
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1125

    
1126
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1127
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1128
            (double)total_size / 1024, ti1, bitrate);
1129

    
1130
        if (verbose > 1)
1131
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1132
                  nb_frames_dup, nb_frames_drop);
1133

    
1134
        if (verbose >= 0)
1135
            fprintf(stderr, "%s    \r", buf);
1136

    
1137
        fflush(stderr);
1138
    }
1139

    
1140
    if (is_last_report && verbose >= 0){
1141
        int64_t raw= audio_size + video_size + extra_size;
1142
        fprintf(stderr, "\n");
1143
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1144
                video_size/1024.0,
1145
                audio_size/1024.0,
1146
                extra_size/1024.0,
1147
                100.0*(total_size - raw)/raw
1148
        );
1149
    }
1150
}
1151

    
1152
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1153
static int output_packet(AVInputStream *ist, int ist_index,
1154
                         AVOutputStream **ost_table, int nb_ostreams,
1155
                         const AVPacket *pkt)
1156
{
1157
    AVFormatContext *os;
1158
    AVOutputStream *ost;
1159
    uint8_t *ptr;
1160
    int len, ret, i;
1161
    uint8_t *data_buf;
1162
    int data_size, got_picture;
1163
    AVFrame picture;
1164
    void *buffer_to_free;
1165
    static unsigned int samples_size= 0;
1166
    static short *samples= NULL;
1167
    AVSubtitle subtitle, *subtitle_to_free;
1168
    int got_subtitle;
1169

    
1170
    if(ist->next_pts == AV_NOPTS_VALUE)
1171
        ist->next_pts= ist->pts;
1172

    
1173
    if (pkt == NULL) {
1174
        /* EOF handling */
1175
        ptr = NULL;
1176
        len = 0;
1177
        goto handle_eof;
1178
    }
1179

    
1180
    if(pkt->dts != AV_NOPTS_VALUE)
1181
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1182

    
1183
    len = pkt->size;
1184
    ptr = pkt->data;
1185

    
1186
    //while we have more to decode or while the decoder did output something on EOF
1187
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1188
    handle_eof:
1189
        ist->pts= ist->next_pts;
1190

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

    
1194
        /* decode the packet if needed */
1195
        data_buf = NULL; /* fail safe */
1196
        data_size = 0;
1197
        subtitle_to_free = NULL;
1198
        if (ist->decoding_needed) {
1199
            switch(ist->st->codec->codec_type) {
1200
            case CODEC_TYPE_AUDIO:{
1201
                if(pkt)
1202
                    samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1203
                data_size= samples_size;
1204
                    /* XXX: could avoid copy if PCM 16 bits with same
1205
                       endianness as CPU */
1206
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1207
                                           ptr, len);
1208
                if (ret < 0)
1209
                    goto fail_decode;
1210
                ptr += ret;
1211
                len -= ret;
1212
                /* Some bug in mpeg audio decoder gives */
1213
                /* data_size < 0, it seems they are overflows */
1214
                if (data_size <= 0) {
1215
                    /* no audio frame */
1216
                    continue;
1217
                }
1218
                data_buf = (uint8_t *)samples;
1219
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1220
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1221
                break;}
1222
            case CODEC_TYPE_VIDEO:
1223
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1224
                    /* XXX: allocate picture correctly */
1225
                    avcodec_get_frame_defaults(&picture);
1226

    
1227
                    ret = avcodec_decode_video(ist->st->codec,
1228
                                               &picture, &got_picture, ptr, len);
1229
                    ist->st->quality= picture.quality;
1230
                    if (ret < 0)
1231
                        goto fail_decode;
1232
                    if (!got_picture) {
1233
                        /* no picture yet */
1234
                        goto discard_packet;
1235
                    }
1236
                    if (ist->st->codec->time_base.num != 0) {
1237
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1238
                                          ist->st->codec->time_base.num) /
1239
                            ist->st->codec->time_base.den;
1240
                    }
1241
                    len = 0;
1242
                    break;
1243
            case CODEC_TYPE_SUBTITLE:
1244
                ret = avcodec_decode_subtitle(ist->st->codec,
1245
                                              &subtitle, &got_subtitle, ptr, len);
1246
                if (ret < 0)
1247
                    goto fail_decode;
1248
                if (!got_subtitle) {
1249
                    goto discard_packet;
1250
                }
1251
                subtitle_to_free = &subtitle;
1252
                len = 0;
1253
                break;
1254
            default:
1255
                goto fail_decode;
1256
            }
1257
        } else {
1258
            switch(ist->st->codec->codec_type) {
1259
            case CODEC_TYPE_AUDIO:
1260
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1261
                    ist->st->codec->sample_rate;
1262
                break;
1263
            case CODEC_TYPE_VIDEO:
1264
                if (ist->st->codec->time_base.num != 0) {
1265
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1266
                                      ist->st->codec->time_base.num) /
1267
                        ist->st->codec->time_base.den;
1268
                }
1269
                break;
1270
            }
1271
            data_buf = ptr;
1272
            data_size = len;
1273
            ret = len;
1274
            len = 0;
1275
        }
1276

    
1277
        buffer_to_free = NULL;
1278
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1279
            pre_process_video_frame(ist, (AVPicture *)&picture,
1280
                                    &buffer_to_free);
1281
        }
1282

    
1283
        // preprocess audio (volume)
1284
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1285
            if (audio_volume != 256) {
1286
                short *volp;
1287
                volp = samples;
1288
                for(i=0;i<(data_size / sizeof(short));i++) {
1289
                    int v = ((*volp) * audio_volume + 128) >> 8;
1290
                    if (v < -32768) v = -32768;
1291
                    if (v >  32767) v = 32767;
1292
                    *volp++ = v;
1293
                }
1294
            }
1295
        }
1296

    
1297
        /* frame rate emulation */
1298
        if (ist->st->codec->rate_emu) {
1299
            int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1300
            int64_t now = av_gettime() - ist->start;
1301
            if (pts > now)
1302
                usleep(pts - now);
1303

    
1304
            ist->frame++;
1305
        }
1306

    
1307
#if 0
1308
        /* mpeg PTS deordering : if it is a P or I frame, the PTS
1309
           is the one of the next displayed one */
1310
        /* XXX: add mpeg4 too ? */
1311
        if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1312
            if (ist->st->codec->pict_type != B_TYPE) {
1313
                int64_t tmp;
1314
                tmp = ist->last_ip_pts;
1315
                ist->last_ip_pts  = ist->frac_pts.val;
1316
                ist->frac_pts.val = tmp;
1317
            }
1318
        }
1319
#endif
1320
        /* if output time reached then transcode raw format,
1321
           encode packets and output them */
1322
        if (start_time == 0 || ist->pts >= start_time)
1323
            for(i=0;i<nb_ostreams;i++) {
1324
                int frame_size;
1325

    
1326
                ost = ost_table[i];
1327
                if (ost->source_index == ist_index) {
1328
                    os = output_files[ost->file_index];
1329

    
1330
#if 0
1331
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1332
                           (double)pkt->pts / AV_TIME_BASE,
1333
                           ((double)ist->pts / AV_TIME_BASE) -
1334
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1335
#endif
1336
                    /* set the input output pts pairs */
1337
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1338

    
1339
                    if (ost->encoding_needed) {
1340
                        switch(ost->st->codec->codec_type) {
1341
                        case CODEC_TYPE_AUDIO:
1342
                            do_audio_out(os, ost, ist, data_buf, data_size);
1343
                            break;
1344
                        case CODEC_TYPE_VIDEO:
1345
                            do_video_out(os, ost, ist, &picture, &frame_size);
1346
                            if (vstats_filename && frame_size)
1347
                                do_video_stats(os, ost, frame_size);
1348
                            break;
1349
                        case CODEC_TYPE_SUBTITLE:
1350
                            do_subtitle_out(os, ost, ist, &subtitle,
1351
                                            pkt->pts);
1352
                            break;
1353
                        default:
1354
                            abort();
1355
                        }
1356
                    } else {
1357
                        AVFrame avframe; //FIXME/XXX remove this
1358
                        AVPacket opkt;
1359
                        av_init_packet(&opkt);
1360

    
1361
                        if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1362
                            continue;
1363

    
1364
                        /* no reencoding needed : output the packet directly */
1365
                        /* force the input stream PTS */
1366

    
1367
                        avcodec_get_frame_defaults(&avframe);
1368
                        ost->st->codec->coded_frame= &avframe;
1369
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1370

    
1371
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1372
                            audio_size += data_size;
1373
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1374
                            video_size += data_size;
1375
                            ost->sync_opts++;
1376
                        }
1377

    
1378
                        opkt.stream_index= ost->index;
1379
                        if(pkt->pts != AV_NOPTS_VALUE)
1380
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1381
                        else
1382
                            opkt.pts= AV_NOPTS_VALUE;
1383

    
1384
                        if (pkt->dts == AV_NOPTS_VALUE)
1385
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1386
                        else
1387
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1388

    
1389
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1390
                        opkt.flags= pkt->flags;
1391

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

    
1396
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1397
                        ost->st->codec->frame_number++;
1398
                        ost->frame_number++;
1399
                        av_free_packet(&opkt);
1400
                    }
1401
                }
1402
            }
1403
        av_free(buffer_to_free);
1404
        /* XXX: allocate the subtitles in the codec ? */
1405
        if (subtitle_to_free) {
1406
            if (subtitle_to_free->rects != NULL) {
1407
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1408
                    av_free(subtitle_to_free->rects[i].bitmap);
1409
                    av_free(subtitle_to_free->rects[i].rgba_palette);
1410
                }
1411
                av_freep(&subtitle_to_free->rects);
1412
            }
1413
            subtitle_to_free->num_rects = 0;
1414
            subtitle_to_free = NULL;
1415
        }
1416
    }
1417
 discard_packet:
1418
    if (pkt == NULL) {
1419
        /* EOF handling */
1420

    
1421
        for(i=0;i<nb_ostreams;i++) {
1422
            ost = ost_table[i];
1423
            if (ost->source_index == ist_index) {
1424
                AVCodecContext *enc= ost->st->codec;
1425
                os = output_files[ost->file_index];
1426

    
1427
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1428
                    continue;
1429
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1430
                    continue;
1431

    
1432
                if (ost->encoding_needed) {
1433
                    for(;;) {
1434
                        AVPacket pkt;
1435
                        int fifo_bytes;
1436
                        av_init_packet(&pkt);
1437
                        pkt.stream_index= ost->index;
1438

    
1439
                        switch(ost->st->codec->codec_type) {
1440
                        case CODEC_TYPE_AUDIO:
1441
                            fifo_bytes = av_fifo_size(&ost->fifo);
1442
                            ret = 0;
1443
                            /* encode any samples remaining in fifo */
1444
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1445
                                int fs_tmp = enc->frame_size;
1446
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1447
                                av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1448
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1449
                                enc->frame_size = fs_tmp;
1450
                            }
1451
                            if(ret <= 0) {
1452
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1453
                            }
1454
                            audio_size += ret;
1455
                            pkt.flags |= PKT_FLAG_KEY;
1456
                            break;
1457
                        case CODEC_TYPE_VIDEO:
1458
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1459
                            video_size += ret;
1460
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1461
                                pkt.flags |= PKT_FLAG_KEY;
1462
                            if (ost->logfile && enc->stats_out) {
1463
                                fprintf(ost->logfile, "%s", enc->stats_out);
1464
                            }
1465
                            break;
1466
                        default:
1467
                            ret=-1;
1468
                        }
1469

    
1470
                        if(ret<=0)
1471
                            break;
1472
                        pkt.data= bit_buffer;
1473
                        pkt.size= ret;
1474
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1475
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1476
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1477
                    }
1478
                }
1479
            }
1480
        }
1481
    }
1482

    
1483
    return 0;
1484
 fail_decode:
1485
    return -1;
1486
}
1487

    
1488
static void print_sdp(AVFormatContext **avc, int n)
1489
{
1490
    char sdp[2048];
1491

    
1492
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1493
    printf("SDP:\n%s\n", sdp);
1494
}
1495

    
1496
static int stream_index_from_inputs(AVFormatContext **input_files,
1497
                                    int nb_input_files,
1498
                                    AVInputFile *file_table,
1499
                                    AVInputStream **ist_table,
1500
                                    enum CodecType type,
1501
                                    int programid)
1502
{
1503
    int p, q, z;
1504
    for(z=0; z<nb_input_files; z++) {
1505
        AVFormatContext *ic = input_files[z];
1506
        for(p=0; p<ic->nb_programs; p++) {
1507
            AVProgram *program = ic->programs[p];
1508
            if(program->id != programid)
1509
                continue;
1510
            for(q=0; q<program->nb_stream_indexes; q++) {
1511
                int sidx = program->stream_index[q];
1512
                int ris = file_table[z].ist_index + sidx;
1513
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1514
                    return ris;
1515
            }
1516
        }
1517
    }
1518

    
1519
    return -1;
1520
}
1521

    
1522
/*
1523
 * The following code is the main loop of the file converter
1524
 */
1525
static int av_encode(AVFormatContext **output_files,
1526
                     int nb_output_files,
1527
                     AVFormatContext **input_files,
1528
                     int nb_input_files,
1529
                     AVStreamMap *stream_maps, int nb_stream_maps)
1530
{
1531
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1532
    AVFormatContext *is, *os;
1533
    AVCodecContext *codec, *icodec;
1534
    AVOutputStream *ost, **ost_table = NULL;
1535
    AVInputStream *ist, **ist_table = NULL;
1536
    AVInputFile *file_table;
1537
    int key;
1538
    int want_sdp = 1;
1539

    
1540
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1541
    if (!file_table)
1542
        goto fail;
1543

    
1544
    /* input stream init */
1545
    j = 0;
1546
    for(i=0;i<nb_input_files;i++) {
1547
        is = input_files[i];
1548
        file_table[i].ist_index = j;
1549
        file_table[i].nb_streams = is->nb_streams;
1550
        j += is->nb_streams;
1551
    }
1552
    nb_istreams = j;
1553

    
1554
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1555
    if (!ist_table)
1556
        goto fail;
1557

    
1558
    for(i=0;i<nb_istreams;i++) {
1559
        ist = av_mallocz(sizeof(AVInputStream));
1560
        if (!ist)
1561
            goto fail;
1562
        ist_table[i] = ist;
1563
    }
1564
    j = 0;
1565
    for(i=0;i<nb_input_files;i++) {
1566
        is = input_files[i];
1567
        for(k=0;k<is->nb_streams;k++) {
1568
            ist = ist_table[j++];
1569
            ist->st = is->streams[k];
1570
            ist->file_index = i;
1571
            ist->index = k;
1572
            ist->discard = 1; /* the stream is discarded by default
1573
                                 (changed later) */
1574

    
1575
            if (ist->st->codec->rate_emu) {
1576
                ist->start = av_gettime();
1577
                ist->frame = 0;
1578
            }
1579
        }
1580
    }
1581

    
1582
    /* output stream init */
1583
    nb_ostreams = 0;
1584
    for(i=0;i<nb_output_files;i++) {
1585
        os = output_files[i];
1586
        if (!os->nb_streams) {
1587
            fprintf(stderr, "Output file does not contain any stream\n");
1588
            av_exit(1);
1589
        }
1590
        nb_ostreams += os->nb_streams;
1591
    }
1592
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1593
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1594
        av_exit(1);
1595
    }
1596

    
1597
    /* Sanity check the mapping args -- do the input files & streams exist? */
1598
    for(i=0;i<nb_stream_maps;i++) {
1599
        int fi = stream_maps[i].file_index;
1600
        int si = stream_maps[i].stream_index;
1601

    
1602
        if (fi < 0 || fi > nb_input_files - 1 ||
1603
            si < 0 || si > file_table[fi].nb_streams - 1) {
1604
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1605
            av_exit(1);
1606
        }
1607
        fi = stream_maps[i].sync_file_index;
1608
        si = stream_maps[i].sync_stream_index;
1609
        if (fi < 0 || fi > nb_input_files - 1 ||
1610
            si < 0 || si > file_table[fi].nb_streams - 1) {
1611
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1612
            av_exit(1);
1613
        }
1614
    }
1615

    
1616
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1617
    if (!ost_table)
1618
        goto fail;
1619
    for(i=0;i<nb_ostreams;i++) {
1620
        ost = av_mallocz(sizeof(AVOutputStream));
1621
        if (!ost)
1622
            goto fail;
1623
        ost_table[i] = ost;
1624
    }
1625

    
1626
    n = 0;
1627
    for(k=0;k<nb_output_files;k++) {
1628
        os = output_files[k];
1629
        for(i=0;i<os->nb_streams;i++) {
1630
            int found;
1631
            ost = ost_table[n++];
1632
            ost->file_index = k;
1633
            ost->index = i;
1634
            ost->st = os->streams[i];
1635
            if (nb_stream_maps > 0) {
1636
                ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1637
                    stream_maps[n-1].stream_index;
1638

    
1639
                /* Sanity check that the stream types match */
1640
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1641
                    int i= ost->file_index;
1642
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1643
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1644
                        stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1645
                        ost->file_index, ost->index);
1646
                    av_exit(1);
1647
                }
1648

    
1649
            } else {
1650
                if(opt_programid) {
1651
                    found = 0;
1652
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1653
                    if(j != -1) {
1654
                        ost->source_index = j;
1655
                        found = 1;
1656
                    }
1657
                } else {
1658
                    /* get corresponding input stream index : we select the first one with the right type */
1659
                    found = 0;
1660
                    for(j=0;j<nb_istreams;j++) {
1661
                        ist = ist_table[j];
1662
                        if (ist->discard &&
1663
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1664
                            ost->source_index = j;
1665
                            found = 1;
1666
                            break;
1667
                        }
1668
                    }
1669
                }
1670

    
1671
                if (!found) {
1672
                    if(! opt_programid) {
1673
                        /* try again and reuse existing stream */
1674
                        for(j=0;j<nb_istreams;j++) {
1675
                            ist = ist_table[j];
1676
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1677
                                ost->source_index = j;
1678
                                found = 1;
1679
                            }
1680
                        }
1681
                    }
1682
                    if (!found) {
1683
                        int i= ost->file_index;
1684
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1685
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1686
                                ost->file_index, ost->index);
1687
                        av_exit(1);
1688
                    }
1689
                }
1690
            }
1691
            ist = ist_table[ost->source_index];
1692
            ist->discard = 0;
1693
            ost->sync_ist = (nb_stream_maps > 0) ?
1694
                ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1695
                         stream_maps[n-1].sync_stream_index] : ist;
1696
        }
1697
    }
1698

    
1699
    /* for each output stream, we compute the right encoding parameters */
1700
    for(i=0;i<nb_ostreams;i++) {
1701
        ost = ost_table[i];
1702
        os = output_files[ost->file_index];
1703
        ist = ist_table[ost->source_index];
1704

    
1705
        codec = ost->st->codec;
1706
        icodec = ist->st->codec;
1707

    
1708
        if (!ost->st->language[0])
1709
            av_strlcpy(ost->st->language, ist->st->language,
1710
                       sizeof(ost->st->language));
1711

    
1712
        ost->st->disposition = ist->st->disposition;
1713

    
1714
        if (ost->st->stream_copy) {
1715
            /* if stream_copy is selected, no need to decode or encode */
1716
            codec->codec_id = icodec->codec_id;
1717
            codec->codec_type = icodec->codec_type;
1718

    
1719
            if(!codec->codec_tag){
1720
                if(   !os->oformat->codec_tag
1721
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1722
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1723
                    codec->codec_tag = icodec->codec_tag;
1724
            }
1725

    
1726
            codec->bit_rate = icodec->bit_rate;
1727
            codec->extradata= icodec->extradata;
1728
            codec->extradata_size= icodec->extradata_size;
1729
            if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1730
                codec->time_base = icodec->time_base;
1731
            else
1732
                codec->time_base = ist->st->time_base;
1733
            switch(codec->codec_type) {
1734
            case CODEC_TYPE_AUDIO:
1735
                if(audio_volume != 256) {
1736
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1737
                    av_exit(1);
1738
                }
1739
                codec->sample_rate = icodec->sample_rate;
1740
                codec->channels = icodec->channels;
1741
                codec->frame_size = icodec->frame_size;
1742
                codec->block_align= icodec->block_align;
1743
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1744
                    codec->block_align= 0;
1745
                if(codec->codec_id == CODEC_ID_AC3)
1746
                    codec->block_align= 0;
1747
                break;
1748
            case CODEC_TYPE_VIDEO:
1749
                if(using_vhook) {
1750
                    fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1751
                    av_exit(1);
1752
                }
1753
                codec->pix_fmt = icodec->pix_fmt;
1754
                codec->width = icodec->width;
1755
                codec->height = icodec->height;
1756
                codec->has_b_frames = icodec->has_b_frames;
1757
                break;
1758
            case CODEC_TYPE_SUBTITLE:
1759
                break;
1760
            default:
1761
                abort();
1762
            }
1763
        } else {
1764
            switch(codec->codec_type) {
1765
            case CODEC_TYPE_AUDIO:
1766
                if (av_fifo_init(&ost->fifo, 1024))
1767
                    goto fail;
1768
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1769
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1770
                icodec->request_channels = codec->channels;
1771
                ist->decoding_needed = 1;
1772
                ost->encoding_needed = 1;
1773
                break;
1774
            case CODEC_TYPE_VIDEO:
1775
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1776
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1777
                ost->video_resample = ((codec->width != icodec->width -
1778
                                (frame_leftBand + frame_rightBand) +
1779
                                (frame_padleft + frame_padright)) ||
1780
                        (codec->height != icodec->height -
1781
                                (frame_topBand  + frame_bottomBand) +
1782
                                (frame_padtop + frame_padbottom)) ||
1783
                        (codec->pix_fmt != icodec->pix_fmt));
1784
                if (ost->video_crop) {
1785
                    ost->topBand = frame_topBand;
1786
                    ost->leftBand = frame_leftBand;
1787
                }
1788
                if (ost->video_pad) {
1789
                    ost->padtop = frame_padtop;
1790
                    ost->padleft = frame_padleft;
1791
                    ost->padbottom = frame_padbottom;
1792
                    ost->padright = frame_padright;
1793
                    if (!ost->video_resample) {
1794
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1795
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1796
                                         codec->width, codec->height))
1797
                            goto fail;
1798
                    }
1799
                }
1800
                if (ost->video_resample) {
1801
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1802
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1803
                                         codec->width, codec->height)) {
1804
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1805
                        av_exit(1);
1806
                    }
1807
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1808
                    ost->img_resample_ctx = sws_getContext(
1809
                            icodec->width - (frame_leftBand + frame_rightBand),
1810
                            icodec->height - (frame_topBand + frame_bottomBand),
1811
                            icodec->pix_fmt,
1812
                            codec->width - (frame_padleft + frame_padright),
1813
                            codec->height - (frame_padtop + frame_padbottom),
1814
                            codec->pix_fmt,
1815
                            sws_flags, NULL, NULL, NULL);
1816
                    if (ost->img_resample_ctx == NULL) {
1817
                        fprintf(stderr, "Cannot get resampling context\n");
1818
                        av_exit(1);
1819
                    }
1820
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1821
                }
1822
                ost->encoding_needed = 1;
1823
                ist->decoding_needed = 1;
1824
                break;
1825
            case CODEC_TYPE_SUBTITLE:
1826
                ost->encoding_needed = 1;
1827
                ist->decoding_needed = 1;
1828
                break;
1829
            default:
1830
                abort();
1831
                break;
1832
            }
1833
            /* two pass mode */
1834
            if (ost->encoding_needed &&
1835
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1836
                char logfilename[1024];
1837
                FILE *f;
1838
                int size;
1839
                char *logbuffer;
1840

    
1841
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1842
                         pass_logfilename ?
1843
                         pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1844
                if (codec->flags & CODEC_FLAG_PASS1) {
1845
                    f = fopen(logfilename, "w");
1846
                    if (!f) {
1847
                        perror(logfilename);
1848
                        av_exit(1);
1849
                    }
1850
                    ost->logfile = f;
1851
                } else {
1852
                    /* read the log file */
1853
                    f = fopen(logfilename, "r");
1854
                    if (!f) {
1855
                        perror(logfilename);
1856
                        av_exit(1);
1857
                    }
1858
                    fseek(f, 0, SEEK_END);
1859
                    size = ftell(f);
1860
                    fseek(f, 0, SEEK_SET);
1861
                    logbuffer = av_malloc(size + 1);
1862
                    if (!logbuffer) {
1863
                        fprintf(stderr, "Could not allocate log buffer\n");
1864
                        av_exit(1);
1865
                    }
1866
                    size = fread(logbuffer, 1, size, f);
1867
                    fclose(f);
1868
                    logbuffer[size] = '\0';
1869
                    codec->stats_in = logbuffer;
1870
                }
1871
            }
1872
        }
1873
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1874
            int size= codec->width * codec->height;
1875
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1876
        }
1877
    }
1878

    
1879
    if (!bit_buffer)
1880
        bit_buffer = av_malloc(bit_buffer_size);
1881
    if (!bit_buffer)
1882
        goto fail;
1883

    
1884
    /* dump the file output parameters - cannot be done before in case
1885
       of stream copy */
1886
    for(i=0;i<nb_output_files;i++) {
1887
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1888
    }
1889

    
1890
    /* dump the stream mapping */
1891
    if (verbose >= 0) {
1892
        fprintf(stderr, "Stream mapping:\n");
1893
        for(i=0;i<nb_ostreams;i++) {
1894
            ost = ost_table[i];
1895
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1896
                    ist_table[ost->source_index]->file_index,
1897
                    ist_table[ost->source_index]->index,
1898
                    ost->file_index,
1899
                    ost->index);
1900
            if (ost->sync_ist != ist_table[ost->source_index])
1901
                fprintf(stderr, " [sync #%d.%d]",
1902
                        ost->sync_ist->file_index,
1903
                        ost->sync_ist->index);
1904
            fprintf(stderr, "\n");
1905
        }
1906
    }
1907

    
1908
    /* open each encoder */
1909
    for(i=0;i<nb_ostreams;i++) {
1910
        ost = ost_table[i];
1911
        if (ost->encoding_needed) {
1912
            AVCodec *codec;
1913
            codec = avcodec_find_encoder(ost->st->codec->codec_id);
1914
            if (!codec) {
1915
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1916
                        ost->file_index, ost->index);
1917
                av_exit(1);
1918
            }
1919
            if (avcodec_open(ost->st->codec, codec) < 0) {
1920
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1921
                        ost->file_index, ost->index);
1922
                av_exit(1);
1923
            }
1924
            extra_size += ost->st->codec->extradata_size;
1925
        }
1926
    }
1927

    
1928
    /* open each decoder */
1929
    for(i=0;i<nb_istreams;i++) {
1930
        ist = ist_table[i];
1931
        if (ist->decoding_needed) {
1932
            AVCodec *codec;
1933
            codec = avcodec_find_decoder(ist->st->codec->codec_id);
1934
            if (!codec) {
1935
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1936
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1937
                av_exit(1);
1938
            }
1939
            if (avcodec_open(ist->st->codec, codec) < 0) {
1940
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1941
                        ist->file_index, ist->index);
1942
                av_exit(1);
1943
            }
1944
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1945
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1946
        }
1947
    }
1948

    
1949
    /* init pts */
1950
    for(i=0;i<nb_istreams;i++) {
1951
        ist = ist_table[i];
1952
        is = input_files[ist->file_index];
1953
        ist->pts = 0;
1954
        ist->next_pts = AV_NOPTS_VALUE;
1955
        ist->is_start = 1;
1956
    }
1957

    
1958
    /* set meta data information from input file if required */
1959
    for (i=0;i<nb_meta_data_maps;i++) {
1960
        AVFormatContext *out_file;
1961
        AVFormatContext *in_file;
1962

    
1963
        int out_file_index = meta_data_maps[i].out_file;
1964
        int in_file_index = meta_data_maps[i].in_file;
1965
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1966
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1967
            ret = AVERROR(EINVAL);
1968
            goto fail;
1969
        }
1970
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1971
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1972
            ret = AVERROR(EINVAL);
1973
            goto fail;
1974
        }
1975

    
1976
        out_file = output_files[out_file_index];
1977
        in_file = input_files[in_file_index];
1978

    
1979
        strcpy(out_file->title, in_file->title);
1980
        strcpy(out_file->author, in_file->author);
1981
        strcpy(out_file->copyright, in_file->copyright);
1982
        strcpy(out_file->comment, in_file->comment);
1983
        strcpy(out_file->album, in_file->album);
1984
        out_file->year = in_file->year;
1985
        out_file->track = in_file->track;
1986
        strcpy(out_file->genre, in_file->genre);
1987
    }
1988

    
1989
    /* open files and write file headers */
1990
    for(i=0;i<nb_output_files;i++) {
1991
        os = output_files[i];
1992
        if (av_write_header(os) < 0) {
1993
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1994
            ret = AVERROR(EINVAL);
1995
            goto fail;
1996
        }
1997
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
1998
            want_sdp = 0;
1999
        }
2000
    }
2001
    if (want_sdp) {
2002
        print_sdp(output_files, nb_output_files);
2003
    }
2004

    
2005
    if (!using_stdin && verbose >= 0) {
2006
        fprintf(stderr, "Press [q] to stop encoding\n");
2007
        url_set_interrupt_cb(decode_interrupt_cb);
2008
    }
2009
    term_init();
2010

    
2011
    key = -1;
2012
    timer_start = av_gettime();
2013

    
2014
    for(; received_sigterm == 0;) {
2015
        int file_index, ist_index;
2016
        AVPacket pkt;
2017
        double ipts_min;
2018
        double opts_min;
2019

    
2020
    redo:
2021
        ipts_min= 1e100;
2022
        opts_min= 1e100;
2023
        /* if 'q' pressed, exits */
2024
        if (!using_stdin) {
2025
            if (q_pressed)
2026
                break;
2027
            /* read_key() returns 0 on EOF */
2028
            key = read_key();
2029
            if (key == 'q')
2030
                break;
2031
        }
2032

    
2033
        /* select the stream that we must read now by looking at the
2034
           smallest output pts */
2035
        file_index = -1;
2036
        for(i=0;i<nb_ostreams;i++) {
2037
            double ipts, opts;
2038
            ost = ost_table[i];
2039
            os = output_files[ost->file_index];
2040
            ist = ist_table[ost->source_index];
2041
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2042
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2043
            else
2044
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2045
            ipts = (double)ist->pts;
2046
            if (!file_table[ist->file_index].eof_reached){
2047
                if(ipts < ipts_min) {
2048
                    ipts_min = ipts;
2049
                    if(input_sync ) file_index = ist->file_index;
2050
                }
2051
                if(opts < opts_min) {
2052
                    opts_min = opts;
2053
                    if(!input_sync) file_index = ist->file_index;
2054
                }
2055
            }
2056
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2057
                file_index= -1;
2058
                break;
2059
            }
2060
        }
2061
        /* if none, if is finished */
2062
        if (file_index < 0) {
2063
            break;
2064
        }
2065

    
2066
        /* finish if recording time exhausted */
2067
        if (opts_min >= (recording_time / 1000000.0))
2068
            break;
2069

    
2070
        /* finish if limit size exhausted */
2071
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2072
            break;
2073

    
2074
        /* read a frame from it and output it in the fifo */
2075
        is = input_files[file_index];
2076
        if (av_read_frame(is, &pkt) < 0) {
2077
            file_table[file_index].eof_reached = 1;
2078
            if (opt_shortest)
2079
                break;
2080
            else
2081
                continue;
2082
        }
2083

    
2084
        if (do_pkt_dump) {
2085
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2086
        }
2087
        /* the following test is needed in case new streams appear
2088
           dynamically in stream : we ignore them */
2089
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2090
            goto discard_packet;
2091
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2092
        ist = ist_table[ist_index];
2093
        if (ist->discard)
2094
            goto discard_packet;
2095

    
2096
        if (pkt.dts != AV_NOPTS_VALUE)
2097
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2098
        if (pkt.pts != AV_NOPTS_VALUE)
2099
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2100

    
2101
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2102
            if(pkt.pts != AV_NOPTS_VALUE)
2103
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2104
            if(pkt.dts != AV_NOPTS_VALUE)
2105
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2106
        }
2107

    
2108
//        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);
2109
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2110
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2111
            int64_t delta= pkt_dts - ist->next_pts;
2112
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2113
                input_files_ts_offset[ist->file_index]-= delta;
2114
                if (verbose > 2)
2115
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2116
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2117
                if(pkt.pts != AV_NOPTS_VALUE)
2118
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2119
            }
2120
        }
2121

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

    
2125
            if (verbose >= 0)
2126
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2127
                        ist->file_index, ist->index);
2128

    
2129
            av_free_packet(&pkt);
2130
            goto redo;
2131
        }
2132

    
2133
    discard_packet:
2134
        av_free_packet(&pkt);
2135

    
2136
        /* dump report by using the output first video and audio streams */
2137
        print_report(output_files, ost_table, nb_ostreams, 0);
2138
    }
2139

    
2140
    /* at the end of stream, we must flush the decoder buffers */
2141
    for(i=0;i<nb_istreams;i++) {
2142
        ist = ist_table[i];
2143
        if (ist->decoding_needed) {
2144
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2145
        }
2146
    }
2147

    
2148
    term_exit();
2149

    
2150
    /* write the trailer if needed and close file */
2151
    for(i=0;i<nb_output_files;i++) {
2152
        os = output_files[i];
2153
        av_write_trailer(os);
2154
    }
2155

    
2156
    /* dump report by using the first video and audio streams */
2157
    print_report(output_files, ost_table, nb_ostreams, 1);
2158

    
2159
    /* close each encoder */
2160
    for(i=0;i<nb_ostreams;i++) {
2161
        ost = ost_table[i];
2162
        if (ost->encoding_needed) {
2163
            av_freep(&ost->st->codec->stats_in);
2164
            avcodec_close(ost->st->codec);
2165
        }
2166
    }
2167

    
2168
    /* close each decoder */
2169
    for(i=0;i<nb_istreams;i++) {
2170
        ist = ist_table[i];
2171
        if (ist->decoding_needed) {
2172
            avcodec_close(ist->st->codec);
2173
        }
2174
    }
2175

    
2176
    /* finished ! */
2177

    
2178
    ret = 0;
2179
 fail1:
2180
    av_freep(&bit_buffer);
2181
    av_free(file_table);
2182

    
2183
    if (ist_table) {
2184
        for(i=0;i<nb_istreams;i++) {
2185
            ist = ist_table[i];
2186
            av_free(ist);
2187
        }
2188
        av_free(ist_table);
2189
    }
2190
    if (ost_table) {
2191
        for(i=0;i<nb_ostreams;i++) {
2192
            ost = ost_table[i];
2193
            if (ost) {
2194
                if (ost->logfile) {
2195
                    fclose(ost->logfile);
2196
                    ost->logfile = NULL;
2197
                }
2198
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2199
                                             initialized but set to zero */
2200
                av_free(ost->pict_tmp.data[0]);
2201
                if (ost->video_resample)
2202
                    sws_freeContext(ost->img_resample_ctx);
2203
                if (ost->resample)
2204
                    audio_resample_close(ost->resample);
2205
                if (ost->reformat_ctx)
2206
                    av_audio_convert_free(ost->reformat_ctx);
2207
                av_free(ost);
2208
            }
2209
        }
2210
        av_free(ost_table);
2211
    }
2212
    return ret;
2213
 fail:
2214
    ret = AVERROR(ENOMEM);
2215
    goto fail1;
2216
}
2217

    
2218
#if 0
2219
int file_read(const char *filename)
2220
{
2221
    URLContext *h;
2222
    unsigned char buffer[1024];
2223
    int len, i;
2224

2225
    if (url_open(&h, filename, O_RDONLY) < 0) {
2226
        printf("could not open '%s'\n", filename);
2227
        return -1;
2228
    }
2229
    for(;;) {
2230
        len = url_read(h, buffer, sizeof(buffer));
2231
        if (len <= 0)
2232
            break;
2233
        for(i=0;i<len;i++) putchar(buffer[i]);
2234
    }
2235
    url_close(h);
2236
    return 0;
2237
}
2238
#endif
2239

    
2240
static void opt_format(const char *arg)
2241
{
2242
    /* compatibility stuff for pgmyuv */
2243
    if (!strcmp(arg, "pgmyuv")) {
2244
        pgmyuv_compatibility_hack=1;
2245
//        opt_image_format(arg);
2246
        arg = "image2";
2247
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2248
    }
2249

    
2250
    file_iformat = av_find_input_format(arg);
2251
    file_oformat = guess_format(arg, NULL, NULL);
2252
    if (!file_iformat && !file_oformat) {
2253
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2254
        av_exit(1);
2255
    }
2256
}
2257

    
2258
static int opt_default(const char *opt, const char *arg){
2259
    int type;
2260
    const AVOption *o= NULL;
2261
    int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2262

    
2263
    for(type=0; type<CODEC_TYPE_NB; type++){
2264
        const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2265
        if(o2)
2266
            o = av_set_string2(avctx_opts[type], opt, arg, 1);
2267
    }
2268
    if(!o)
2269
        o = av_set_string2(avformat_opts, opt, arg, 1);
2270
    if(!o)
2271
        o = av_set_string2(sws_opts, opt, arg, 1);
2272
    if(!o){
2273
        if(opt[0] == 'a')
2274
            o = av_set_string2(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1);
2275
        else if(opt[0] == 'v')
2276
            o = av_set_string2(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1);
2277
        else if(opt[0] == 's')
2278
            o = av_set_string2(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1);
2279
    }
2280
    if(!o)
2281
        return -1;
2282

    
2283
//    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));
2284

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

    
2289
    if(avctx_opts[0]->debug || avformat_opts->debug)
2290
        av_log_set_level(AV_LOG_DEBUG);
2291
    return 0;
2292
}
2293

    
2294
static void opt_video_rc_override_string(const char *arg)
2295
{
2296
    video_rc_override_string = arg;
2297
}
2298

    
2299
static int opt_me_threshold(const char *opt, const char *arg)
2300
{
2301
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2302
    return 0;
2303
}
2304

    
2305
static int opt_verbose(const char *opt, const char *arg)
2306
{
2307
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2308
    av_log_set_level(verbose);
2309
    return 0;
2310
}
2311

    
2312
static void opt_frame_rate(const char *arg)
2313
{
2314
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2315
        fprintf(stderr, "Incorrect frame rate\n");
2316
        av_exit(1);
2317
    }
2318
}
2319

    
2320
static int opt_bitrate(const char *opt, const char *arg)
2321
{
2322
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2323

    
2324
    opt_default(opt, arg);
2325

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

    
2329
    return 0;
2330
}
2331

    
2332
static void opt_frame_crop_top(const char *arg)
2333
{
2334
    frame_topBand = atoi(arg);
2335
    if (frame_topBand < 0) {
2336
        fprintf(stderr, "Incorrect top crop size\n");
2337
        av_exit(1);
2338
    }
2339
    if ((frame_topBand % 2) != 0) {
2340
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2341
        av_exit(1);
2342
    }
2343
    if ((frame_topBand) >= frame_height){
2344
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2345
        av_exit(1);
2346
    }
2347
    frame_height -= frame_topBand;
2348
}
2349

    
2350
static void opt_frame_crop_bottom(const char *arg)
2351
{
2352
    frame_bottomBand = atoi(arg);
2353
    if (frame_bottomBand < 0) {
2354
        fprintf(stderr, "Incorrect bottom crop size\n");
2355
        av_exit(1);
2356
    }
2357
    if ((frame_bottomBand % 2) != 0) {
2358
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2359
        av_exit(1);
2360
    }
2361
    if ((frame_bottomBand) >= frame_height){
2362
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2363
        av_exit(1);
2364
    }
2365
    frame_height -= frame_bottomBand;
2366
}
2367

    
2368
static void opt_frame_crop_left(const char *arg)
2369
{
2370
    frame_leftBand = atoi(arg);
2371
    if (frame_leftBand < 0) {
2372
        fprintf(stderr, "Incorrect left crop size\n");
2373
        av_exit(1);
2374
    }
2375
    if ((frame_leftBand % 2) != 0) {
2376
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2377
        av_exit(1);
2378
    }
2379
    if ((frame_leftBand) >= frame_width){
2380
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2381
        av_exit(1);
2382
    }
2383
    frame_width -= frame_leftBand;
2384
}
2385

    
2386
static void opt_frame_crop_right(const char *arg)
2387
{
2388
    frame_rightBand = atoi(arg);
2389
    if (frame_rightBand < 0) {
2390
        fprintf(stderr, "Incorrect right crop size\n");
2391
        av_exit(1);
2392
    }
2393
    if ((frame_rightBand % 2) != 0) {
2394
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2395
        av_exit(1);
2396
    }
2397
    if ((frame_rightBand) >= frame_width){
2398
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2399
        av_exit(1);
2400
    }
2401
    frame_width -= frame_rightBand;
2402
}
2403

    
2404
static void opt_frame_size(const char *arg)
2405
{
2406
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2407
        fprintf(stderr, "Incorrect frame size\n");
2408
        av_exit(1);
2409
    }
2410
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2411
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2412
        av_exit(1);
2413
    }
2414
}
2415

    
2416

    
2417
#define SCALEBITS 10
2418
#define ONE_HALF  (1 << (SCALEBITS - 1))
2419
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2420

    
2421
#define RGB_TO_Y(r, g, b) \
2422
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2423
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2424

    
2425
#define RGB_TO_U(r1, g1, b1, shift)\
2426
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2427
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2428

    
2429
#define RGB_TO_V(r1, g1, b1, shift)\
2430
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2431
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2432

    
2433
static void opt_pad_color(const char *arg) {
2434
    /* Input is expected to be six hex digits similar to
2435
       how colors are expressed in html tags (but without the #) */
2436
    int rgb = strtol(arg, NULL, 16);
2437
    int r,g,b;
2438

    
2439
    r = (rgb >> 16);
2440
    g = ((rgb >> 8) & 255);
2441
    b = (rgb & 255);
2442

    
2443
    padcolor[0] = RGB_TO_Y(r,g,b);
2444
    padcolor[1] = RGB_TO_U(r,g,b,0);
2445
    padcolor[2] = RGB_TO_V(r,g,b,0);
2446
}
2447

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

    
2461
static void opt_frame_pad_bottom(const char *arg)
2462
{
2463
    frame_padbottom = atoi(arg);
2464
    if (frame_padbottom < 0) {
2465
        fprintf(stderr, "Incorrect bottom pad size\n");
2466
        av_exit(1);
2467
    }
2468
    if ((frame_padbottom % 2) != 0) {
2469
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2470
        av_exit(1);
2471
    }
2472
}
2473

    
2474

    
2475
static void opt_frame_pad_left(const char *arg)
2476
{
2477
    frame_padleft = atoi(arg);
2478
    if (frame_padleft < 0) {
2479
        fprintf(stderr, "Incorrect left pad size\n");
2480
        av_exit(1);
2481
    }
2482
    if ((frame_padleft % 2) != 0) {
2483
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2484
        av_exit(1);
2485
    }
2486
}
2487

    
2488

    
2489
static void opt_frame_pad_right(const char *arg)
2490
{
2491
    frame_padright = atoi(arg);
2492
    if (frame_padright < 0) {
2493
        fprintf(stderr, "Incorrect right pad size\n");
2494
        av_exit(1);
2495
    }
2496
    if ((frame_padright % 2) != 0) {
2497
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2498
        av_exit(1);
2499
    }
2500
}
2501

    
2502
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2503
{
2504
    int i;
2505
    char fmt_str[128];
2506
    for (i=-1; i < nb_fmts; i++) {
2507
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2508
        fprintf(stdout, "%s\n", fmt_str);
2509
    }
2510
}
2511

    
2512
static void opt_frame_pix_fmt(const char *arg)
2513
{
2514
    if (strcmp(arg, "list"))
2515
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2516
    else {
2517
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2518
        av_exit(0);
2519
    }
2520
}
2521

    
2522
static void opt_frame_aspect_ratio(const char *arg)
2523
{
2524
    int x = 0, y = 0;
2525
    double ar = 0;
2526
    const char *p;
2527
    char *end;
2528

    
2529
    p = strchr(arg, ':');
2530
    if (p) {
2531
        x = strtol(arg, &end, 10);
2532
        if (end == p)
2533
            y = strtol(end+1, &end, 10);
2534
        if (x > 0 && y > 0)
2535
            ar = (double)x / (double)y;
2536
    } else
2537
        ar = strtod(arg, NULL);
2538

    
2539
    if (!ar) {
2540
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2541
        av_exit(1);
2542
    }
2543
    frame_aspect_ratio = ar;
2544
}
2545

    
2546
static void opt_qscale(const char *arg)
2547
{
2548
    video_qscale = atof(arg);
2549
    if (video_qscale <= 0 ||
2550
        video_qscale > 255) {
2551
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2552
        av_exit(1);
2553
    }
2554
}
2555

    
2556
static void opt_top_field_first(const char *arg)
2557
{
2558
    top_field_first= atoi(arg);
2559
}
2560

    
2561
static int opt_thread_count(const char *opt, const char *arg)
2562
{
2563
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2564
#if !defined(HAVE_THREADS)
2565
    if (verbose >= 0)
2566
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2567
#endif
2568
    return 0;
2569
}
2570

    
2571
static void opt_audio_sample_fmt(const char *arg)
2572
{
2573
    if (strcmp(arg, "list"))
2574
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2575
    else {
2576
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2577
        av_exit(0);
2578
    }
2579
}
2580

    
2581
static int opt_audio_rate(const char *opt, const char *arg)
2582
{
2583
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2584
    return 0;
2585
}
2586

    
2587
static int opt_audio_channels(const char *opt, const char *arg)
2588
{
2589
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2590
    return 0;
2591
}
2592

    
2593
static void opt_video_channel(const char *arg)
2594
{
2595
    video_channel = strtol(arg, NULL, 0);
2596
}
2597

    
2598
static void opt_video_standard(const char *arg)
2599
{
2600
    video_standard = av_strdup(arg);
2601
}
2602

    
2603
static void opt_codec(int *pstream_copy, char **pcodec_name,
2604
                      int codec_type, const char *arg)
2605
{
2606
    av_freep(pcodec_name);
2607
    if (!strcmp(arg, "copy")) {
2608
        *pstream_copy = 1;
2609
    } else {
2610
        *pcodec_name = av_strdup(arg);
2611
    }
2612
}
2613

    
2614
static void opt_audio_codec(const char *arg)
2615
{
2616
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2617
}
2618

    
2619
static void opt_audio_tag(const char *arg)
2620
{
2621
    char *tail;
2622
    audio_codec_tag= strtol(arg, &tail, 0);
2623

    
2624
    if(!tail || *tail)
2625
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2626
}
2627

    
2628
static void opt_video_tag(const char *arg)
2629
{
2630
    char *tail;
2631
    video_codec_tag= strtol(arg, &tail, 0);
2632

    
2633
    if(!tail || *tail)
2634
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2635
}
2636

    
2637
#ifdef CONFIG_VHOOK
2638
static void add_frame_hooker(const char *arg)
2639
{
2640
    int argc = 0;
2641
    char *argv[64];
2642
    int i;
2643
    char *args = av_strdup(arg);
2644

    
2645
    using_vhook = 1;
2646

    
2647
    argv[0] = strtok(args, " ");
2648
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2649
    }
2650

    
2651
    i = frame_hook_add(argc, argv);
2652

    
2653
    if (i != 0) {
2654
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2655
        av_exit(1);
2656
    }
2657
}
2658
#endif
2659

    
2660
static void opt_video_codec(const char *arg)
2661
{
2662
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2663
}
2664

    
2665
static void opt_subtitle_codec(const char *arg)
2666
{
2667
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2668
}
2669

    
2670
static void opt_map(const char *arg)
2671
{
2672
    AVStreamMap *m;
2673
    char *p;
2674

    
2675
    m = &stream_maps[nb_stream_maps++];
2676

    
2677
    m->file_index = strtol(arg, &p, 0);
2678
    if (*p)
2679
        p++;
2680

    
2681
    m->stream_index = strtol(p, &p, 0);
2682
    if (*p) {
2683
        p++;
2684
        m->sync_file_index = strtol(p, &p, 0);
2685
        if (*p)
2686
            p++;
2687
        m->sync_stream_index = strtol(p, &p, 0);
2688
    } else {
2689
        m->sync_file_index = m->file_index;
2690
        m->sync_stream_index = m->stream_index;
2691
    }
2692
}
2693

    
2694
static void opt_map_meta_data(const char *arg)
2695
{
2696
    AVMetaDataMap *m;
2697
    char *p;
2698

    
2699
    m = &meta_data_maps[nb_meta_data_maps++];
2700

    
2701
    m->out_file = strtol(arg, &p, 0);
2702
    if (*p)
2703
        p++;
2704

    
2705
    m->in_file = strtol(p, &p, 0);
2706
}
2707

    
2708
static void opt_input_ts_scale(const char *arg)
2709
{
2710
    unsigned int stream;
2711
    double scale;
2712
    char *p;
2713

    
2714
    stream = strtol(arg, &p, 0);
2715
    if (*p)
2716
        p++;
2717
    scale= strtod(p, &p);
2718

    
2719
    if(stream >= MAX_STREAMS)
2720
        av_exit(1);
2721

    
2722
    input_files_ts_scale[nb_input_files][stream]= scale;
2723
}
2724

    
2725
static int opt_recording_time(const char *opt, const char *arg)
2726
{
2727
    recording_time = parse_time_or_die(opt, arg, 1);
2728
    return 0;
2729
}
2730

    
2731
static int opt_start_time(const char *opt, const char *arg)
2732
{
2733
    start_time = parse_time_or_die(opt, arg, 1);
2734
    return 0;
2735
}
2736

    
2737
static int opt_rec_timestamp(const char *opt, const char *arg)
2738
{
2739
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2740
    return 0;
2741
}
2742

    
2743
static int opt_input_ts_offset(const char *opt, const char *arg)
2744
{
2745
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2746
    return 0;
2747
}
2748

    
2749
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2750
{
2751
    const char *codec_string = encoder ? "encoder" : "decoder";
2752
    AVCodec *codec;
2753

    
2754
    if(!name)
2755
        return CODEC_ID_NONE;
2756
    codec = encoder ?
2757
        avcodec_find_encoder_by_name(name) :
2758
        avcodec_find_decoder_by_name(name);
2759
    if(!codec) {
2760
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2761
        av_exit(1);
2762
    }
2763
    if(codec->type != type) {
2764
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2765
        av_exit(1);
2766
    }
2767
    return codec->id;
2768
}
2769

    
2770
static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2771
{
2772
    int i;
2773
    for(i=0; i<opt_name_count; i++){
2774
        char buf[256];
2775
        const AVOption *opt;
2776
        const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2777
        /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2778
        if(str && ((opt->flags & flags) == flags))
2779
            av_set_string2(ctx, opt_names[i], str, 1);
2780
    }
2781
}
2782

    
2783
static void opt_input_file(const char *filename)
2784
{
2785
    AVFormatContext *ic;
2786
    AVFormatParameters params, *ap = &params;
2787
    int err, i, ret, rfps, rfps_base;
2788
    int64_t timestamp;
2789

    
2790
    if (!strcmp(filename, "-"))
2791
        filename = "pipe:";
2792

    
2793
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2794
                    !strcmp(filename, "/dev/stdin");
2795

    
2796
    /* get default parameters from command line */
2797
    ic = av_alloc_format_context();
2798

    
2799
    memset(ap, 0, sizeof(*ap));
2800
    ap->prealloced_context = 1;
2801
    ap->sample_rate = audio_sample_rate;
2802
    ap->channels = audio_channels;
2803
    ap->time_base.den = frame_rate.num;
2804
    ap->time_base.num = frame_rate.den;
2805
    ap->width = frame_width + frame_padleft + frame_padright;
2806
    ap->height = frame_height + frame_padtop + frame_padbottom;
2807
    ap->pix_fmt = frame_pix_fmt;
2808
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2809
    ap->channel = video_channel;
2810
    ap->standard = video_standard;
2811
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2812
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2813
    if(pgmyuv_compatibility_hack)
2814
        ap->video_codec_id= CODEC_ID_PGMYUV;
2815

    
2816
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2817

    
2818
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2819
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2820
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2821

    
2822
    /* open the input file with generic libav function */
2823
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2824
    if (err < 0) {
2825
        print_error(filename, err);
2826
        av_exit(1);
2827
    }
2828
    if(opt_programid) {
2829
        int i;
2830
        for(i=0; i<ic->nb_programs; i++)
2831
            if(ic->programs[i]->id != opt_programid)
2832
                ic->programs[i]->discard = AVDISCARD_ALL;
2833
    }
2834

    
2835
    ic->loop_input = loop_input;
2836

    
2837
    /* If not enough info to get the stream parameters, we decode the
2838
       first frames to get it. (used in mpeg case for example) */
2839
    ret = av_find_stream_info(ic);
2840
    if (ret < 0 && verbose >= 0) {
2841
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2842
        av_exit(1);
2843
    }
2844

    
2845
    timestamp = start_time;
2846
    /* add the stream start time */
2847
    if (ic->start_time != AV_NOPTS_VALUE)
2848
        timestamp += ic->start_time;
2849

    
2850
    /* if seeking requested, we execute it */
2851
    if (start_time != 0) {
2852
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2853
        if (ret < 0) {
2854
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2855
                    filename, (double)timestamp / AV_TIME_BASE);
2856
        }
2857
        /* reset seek info */
2858
        start_time = 0;
2859
    }
2860

    
2861
    /* update the current parameters so that they match the one of the input stream */
2862
    for(i=0;i<ic->nb_streams;i++) {
2863
        AVCodecContext *enc = ic->streams[i]->codec;
2864
        if(thread_count>1)
2865
            avcodec_thread_init(enc, thread_count);
2866
        enc->thread_count= thread_count;
2867
        switch(enc->codec_type) {
2868
        case CODEC_TYPE_AUDIO:
2869
            set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2870
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2871
            audio_channels = enc->channels;
2872
            audio_sample_rate = enc->sample_rate;
2873
            audio_sample_fmt = enc->sample_fmt;
2874
            if(audio_disable)
2875
                ic->streams[i]->discard= AVDISCARD_ALL;
2876
            break;
2877
        case CODEC_TYPE_VIDEO:
2878
            set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2879
            frame_height = enc->height;
2880
            frame_width = enc->width;
2881
            frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2882
            frame_pix_fmt = enc->pix_fmt;
2883
            rfps      = ic->streams[i]->r_frame_rate.num;
2884
            rfps_base = ic->streams[i]->r_frame_rate.den;
2885
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2886
            if(me_threshold)
2887
                enc->debug |= FF_DEBUG_MV;
2888

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

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

    
2895
                    (float)rfps / rfps_base, rfps, rfps_base);
2896
            }
2897
            /* update the current frame rate to match the stream frame rate */
2898
            frame_rate.num = rfps;
2899
            frame_rate.den = rfps_base;
2900

    
2901
            enc->rate_emu = rate_emu;
2902
            if(video_disable)
2903
                ic->streams[i]->discard= AVDISCARD_ALL;
2904
            else if(video_discard)
2905
                ic->streams[i]->discard= video_discard;
2906
            break;
2907
        case CODEC_TYPE_DATA:
2908
            break;
2909
        case CODEC_TYPE_SUBTITLE:
2910
            if(subtitle_disable)
2911
                ic->streams[i]->discard = AVDISCARD_ALL;
2912
            break;
2913
        case CODEC_TYPE_ATTACHMENT:
2914
        case CODEC_TYPE_UNKNOWN:
2915
            break;
2916
        default:
2917
            abort();
2918
        }
2919
    }
2920

    
2921
    input_files[nb_input_files] = ic;
2922
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2923
    /* dump the file content */
2924
    if (verbose >= 0)
2925
        dump_format(ic, nb_input_files, filename, 0);
2926

    
2927
    nb_input_files++;
2928
    file_iformat = NULL;
2929
    file_oformat = NULL;
2930

    
2931
    video_channel = 0;
2932

    
2933
    rate_emu = 0;
2934
    av_freep(&video_codec_name);
2935
    av_freep(&audio_codec_name);
2936
    av_freep(&subtitle_codec_name);
2937
}
2938

    
2939
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2940
                                         int *has_subtitle_ptr)
2941
{
2942
    int has_video, has_audio, has_subtitle, i, j;
2943
    AVFormatContext *ic;
2944

    
2945
    has_video = 0;
2946
    has_audio = 0;
2947
    has_subtitle = 0;
2948
    for(j=0;j<nb_input_files;j++) {
2949
        ic = input_files[j];
2950
        for(i=0;i<ic->nb_streams;i++) {
2951
            AVCodecContext *enc = ic->streams[i]->codec;
2952
            switch(enc->codec_type) {
2953
            case CODEC_TYPE_AUDIO:
2954
                has_audio = 1;
2955
                break;
2956
            case CODEC_TYPE_VIDEO:
2957
                has_video = 1;
2958
                break;
2959
            case CODEC_TYPE_SUBTITLE:
2960
                has_subtitle = 1;
2961
                break;
2962
            case CODEC_TYPE_DATA:
2963
            case CODEC_TYPE_ATTACHMENT:
2964
            case CODEC_TYPE_UNKNOWN:
2965
                break;
2966
            default:
2967
                abort();
2968
            }
2969
        }
2970
    }
2971
    *has_video_ptr = has_video;
2972
    *has_audio_ptr = has_audio;
2973
    *has_subtitle_ptr = has_subtitle;
2974
}
2975

    
2976
static void new_video_stream(AVFormatContext *oc)
2977
{
2978
    AVStream *st;
2979
    AVCodecContext *video_enc;
2980
    int codec_id;
2981

    
2982
    st = av_new_stream(oc, oc->nb_streams);
2983
    if (!st) {
2984
        fprintf(stderr, "Could not alloc stream\n");
2985
        av_exit(1);
2986
    }
2987
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2988
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2989
    video_bitstream_filters= NULL;
2990

    
2991
    if(thread_count>1)
2992
        avcodec_thread_init(st->codec, thread_count);
2993

    
2994
    video_enc = st->codec;
2995

    
2996
    if(video_codec_tag)
2997
        video_enc->codec_tag= video_codec_tag;
2998

    
2999
    if(   (video_global_header&1)
3000
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3001
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3002
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3003
    }
3004
    if(video_global_header&2){
3005
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3006
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3007
    }
3008

    
3009
    if (video_stream_copy) {
3010
        st->stream_copy = 1;
3011
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3012
    } else {
3013
        const char *p;
3014
        int i;
3015
        AVCodec *codec;
3016
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3017

    
3018
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3019
        if (video_codec_name)
3020
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3021

    
3022
        video_enc->codec_id = codec_id;
3023
        codec = avcodec_find_encoder(codec_id);
3024

    
3025
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3026

    
3027
        video_enc->time_base.den = fps.num;
3028
        video_enc->time_base.num = fps.den;
3029
        if(codec && codec->supported_framerates){
3030
            const AVRational *p= codec->supported_framerates;
3031
            const AVRational *best=NULL;
3032
            AVRational best_error= (AVRational){INT_MAX, 1};
3033
            for(; p->den!=0; p++){
3034
                AVRational error= av_sub_q(fps, *p);
3035
                if(error.num <0) error.num *= -1;
3036
                if(av_cmp_q(error, best_error) < 0){
3037
                    best_error= error;
3038
                    best= p;
3039
                }
3040
            }
3041
            video_enc->time_base.den= best->num;
3042
            video_enc->time_base.num= best->den;
3043
        }
3044

    
3045
        video_enc->width = frame_width + frame_padright + frame_padleft;
3046
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3047
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3048
        video_enc->pix_fmt = frame_pix_fmt;
3049

    
3050
        if(codec && codec->pix_fmts){
3051
            const enum PixelFormat *p= codec->pix_fmts;
3052
            for(; *p!=-1; p++){
3053
                if(*p == video_enc->pix_fmt)
3054
                    break;
3055
            }
3056
            if(*p == -1)
3057
                video_enc->pix_fmt = codec->pix_fmts[0];
3058
        }
3059

    
3060
        if (intra_only)
3061
            video_enc->gop_size = 0;
3062
        if (video_qscale || same_quality) {
3063
            video_enc->flags |= CODEC_FLAG_QSCALE;
3064
            video_enc->global_quality=
3065
                st->quality = FF_QP2LAMBDA * video_qscale;
3066
        }
3067

    
3068
        if(intra_matrix)
3069
            video_enc->intra_matrix = intra_matrix;
3070
        if(inter_matrix)
3071
            video_enc->inter_matrix = inter_matrix;
3072

    
3073
        video_enc->thread_count = thread_count;
3074
        p= video_rc_override_string;
3075
        for(i=0; p; i++){
3076
            int start, end, q;
3077
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3078
            if(e!=3){
3079
                fprintf(stderr, "error parsing rc_override\n");
3080
                av_exit(1);
3081
            }
3082
            video_enc->rc_override=
3083
                av_realloc(video_enc->rc_override,
3084
                           sizeof(RcOverride)*(i+1));
3085
            video_enc->rc_override[i].start_frame= start;
3086
            video_enc->rc_override[i].end_frame  = end;
3087
            if(q>0){
3088
                video_enc->rc_override[i].qscale= q;
3089
                video_enc->rc_override[i].quality_factor= 1.0;
3090
            }
3091
            else{
3092
                video_enc->rc_override[i].qscale= 0;
3093
                video_enc->rc_override[i].quality_factor= -q/100.0;
3094
            }
3095
            p= strchr(p, '/');
3096
            if(p) p++;
3097
        }
3098
        video_enc->rc_override_count=i;
3099
        if (!video_enc->rc_initial_buffer_occupancy)
3100
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3101
        video_enc->me_threshold= me_threshold;
3102
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3103

    
3104
        if (do_psnr)
3105
            video_enc->flags|= CODEC_FLAG_PSNR;
3106

    
3107
        /* two pass mode */
3108
        if (do_pass) {
3109
            if (do_pass == 1) {
3110
                video_enc->flags |= CODEC_FLAG_PASS1;
3111
            } else {
3112
                video_enc->flags |= CODEC_FLAG_PASS2;
3113
            }
3114
        }
3115
    }
3116

    
3117
    /* reset some key parameters */
3118
    video_disable = 0;
3119
    av_freep(&video_codec_name);
3120
    video_stream_copy = 0;
3121
}
3122

    
3123
static void new_audio_stream(AVFormatContext *oc)
3124
{
3125
    AVStream *st;
3126
    AVCodecContext *audio_enc;
3127
    int codec_id;
3128

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

    
3136
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3137
    audio_bitstream_filters= NULL;
3138

    
3139
    if(thread_count>1)
3140
        avcodec_thread_init(st->codec, thread_count);
3141

    
3142
    audio_enc = st->codec;
3143
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3144

    
3145
    if(audio_codec_tag)
3146
        audio_enc->codec_tag= audio_codec_tag;
3147

    
3148
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3149
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3150
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3151
    }
3152
    if (audio_stream_copy) {
3153
        st->stream_copy = 1;
3154
        audio_enc->channels = audio_channels;
3155
    } else {
3156
        AVCodec *codec;
3157
        codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3158

    
3159
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3160

    
3161
        if (audio_codec_name)
3162
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3163
        audio_enc->codec_id = codec_id;
3164
        codec = avcodec_find_encoder(codec_id);
3165

    
3166
        if (audio_qscale > QSCALE_NONE) {
3167
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3168
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3169
        }
3170
        audio_enc->thread_count = thread_count;
3171
        audio_enc->channels = audio_channels;
3172
        audio_enc->sample_fmt = audio_sample_fmt;
3173

    
3174
        if(codec && codec->sample_fmts){
3175
            const enum SampleFormat *p= codec->sample_fmts;
3176
            for(; *p!=-1; p++){
3177
                if(*p == audio_enc->sample_fmt)
3178
                    break;
3179
            }
3180
            if(*p == -1)
3181
                audio_enc->sample_fmt = codec->sample_fmts[0];
3182
        }
3183
    }
3184
    audio_enc->sample_rate = audio_sample_rate;
3185
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3186
    if (audio_language) {
3187
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3188
        av_free(audio_language);
3189
        audio_language = NULL;
3190
    }
3191

    
3192
    /* reset some key parameters */
3193
    audio_disable = 0;
3194
    av_freep(&audio_codec_name);
3195
    audio_stream_copy = 0;
3196
}
3197

    
3198
static void new_subtitle_stream(AVFormatContext *oc)
3199
{
3200
    AVStream *st;
3201
    AVCodecContext *subtitle_enc;
3202

    
3203
    st = av_new_stream(oc, oc->nb_streams);
3204
    if (!st) {
3205
        fprintf(stderr, "Could not alloc stream\n");
3206
        av_exit(1);
3207
    }
3208
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3209

    
3210
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3211
    subtitle_bitstream_filters= NULL;
3212

    
3213
    subtitle_enc = st->codec;
3214
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3215
    if (subtitle_stream_copy) {
3216
        st->stream_copy = 1;
3217
    } else {
3218
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3219
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3220
    }
3221

    
3222
    if (subtitle_language) {
3223
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3224
        av_free(subtitle_language);
3225
        subtitle_language = NULL;
3226
    }
3227

    
3228
    subtitle_disable = 0;
3229
    av_freep(&subtitle_codec_name);
3230
    subtitle_stream_copy = 0;
3231
}
3232

    
3233
static void opt_new_audio_stream(void)
3234
{
3235
    AVFormatContext *oc;
3236
    if (nb_output_files <= 0) {
3237
        fprintf(stderr, "At least one output file must be specified\n");
3238
        av_exit(1);
3239
    }
3240
    oc = output_files[nb_output_files - 1];
3241
    new_audio_stream(oc);
3242
}
3243

    
3244
static void opt_new_video_stream(void)
3245
{
3246
    AVFormatContext *oc;
3247
    if (nb_output_files <= 0) {
3248
        fprintf(stderr, "At least one output file must be specified\n");
3249
        av_exit(1);
3250
    }
3251
    oc = output_files[nb_output_files - 1];
3252
    new_video_stream(oc);
3253
}
3254

    
3255
static void opt_new_subtitle_stream(void)
3256
{
3257
    AVFormatContext *oc;
3258
    if (nb_output_files <= 0) {
3259
        fprintf(stderr, "At least one output file must be specified\n");
3260
        av_exit(1);
3261
    }
3262
    oc = output_files[nb_output_files - 1];
3263
    new_subtitle_stream(oc);
3264
}
3265

    
3266
static void opt_output_file(const char *filename)
3267
{
3268
    AVFormatContext *oc;
3269
    int use_video, use_audio, use_subtitle;
3270
    int input_has_video, input_has_audio, input_has_subtitle;
3271
    AVFormatParameters params, *ap = &params;
3272

    
3273
    if (!strcmp(filename, "-"))
3274
        filename = "pipe:";
3275

    
3276
    oc = av_alloc_format_context();
3277

    
3278
    if (!file_oformat) {
3279
        file_oformat = guess_format(NULL, filename, NULL);
3280
        if (!file_oformat) {
3281
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3282
                    filename);
3283
            av_exit(1);
3284
        }
3285
    }
3286

    
3287
    oc->oformat = file_oformat;
3288
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3289

    
3290
    if (!strcmp(file_oformat->name, "ffm") &&
3291
        av_strstart(filename, "http:", NULL)) {
3292
        /* special case for files sent to ffserver: we get the stream
3293
           parameters from ffserver */
3294
        int err = read_ffserver_streams(oc, filename);
3295
        if (err < 0) {
3296
            print_error(filename, err);
3297
            av_exit(1);
3298
        }
3299
    } else {
3300
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3301
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3302
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3303

    
3304
        /* disable if no corresponding type found and at least one
3305
           input file */
3306
        if (nb_input_files > 0) {
3307
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3308
                                         &input_has_subtitle);
3309
            if (!input_has_video)
3310
                use_video = 0;
3311
            if (!input_has_audio)
3312
                use_audio = 0;
3313
            if (!input_has_subtitle)
3314
                use_subtitle = 0;
3315
        }
3316

    
3317
        /* manual disable */
3318
        if (audio_disable) {
3319
            use_audio = 0;
3320
        }
3321
        if (video_disable) {
3322
            use_video = 0;
3323
        }
3324
        if (subtitle_disable) {
3325
            use_subtitle = 0;
3326
        }
3327

    
3328
        if (use_video) {
3329
            new_video_stream(oc);
3330
        }
3331

    
3332
        if (use_audio) {
3333
            new_audio_stream(oc);
3334
        }
3335

    
3336
        if (use_subtitle) {
3337
            new_subtitle_stream(oc);
3338
        }
3339

    
3340
        oc->timestamp = rec_timestamp;
3341

    
3342
        if (str_title)
3343
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3344
        if (str_author)
3345
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3346
        if (str_copyright)
3347
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3348
        if (str_comment)
3349
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3350
        if (str_album)
3351
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3352
        if (str_genre)
3353
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3354
    }
3355

    
3356
    output_files[nb_output_files++] = oc;
3357

    
3358
    /* check filename in case of an image number is expected */
3359
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3360
        if (!av_filename_number_test(oc->filename)) {
3361
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3362
            av_exit(1);
3363
        }
3364
    }
3365

    
3366
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3367
        /* test if it already exists to avoid loosing precious files */
3368
        if (!file_overwrite &&
3369
            (strchr(filename, ':') == NULL ||
3370
             filename[1] == ':' ||
3371
             av_strstart(filename, "file:", NULL))) {
3372
            if (url_exist(filename)) {
3373
                int c;
3374

    
3375
                if (!using_stdin) {
3376
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3377
                    fflush(stderr);
3378
                    c = getchar();
3379
                    if (toupper(c) != 'Y') {
3380
                        fprintf(stderr, "Not overwriting - exiting\n");
3381
                        av_exit(1);
3382
                    }
3383
                }
3384
                else {
3385
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3386
                    av_exit(1);
3387
                }
3388
            }
3389
        }
3390

    
3391
        /* open the file */
3392
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3393
            fprintf(stderr, "Could not open '%s'\n", filename);
3394
            av_exit(1);
3395
        }
3396
    }
3397

    
3398
    memset(ap, 0, sizeof(*ap));
3399
    if (av_set_parameters(oc, ap) < 0) {
3400
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3401
                oc->filename);
3402
        av_exit(1);
3403
    }
3404

    
3405
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3406
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3407
    oc->loop_output = loop_output;
3408

    
3409
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3410

    
3411
    /* reset some options */
3412
    file_oformat = NULL;
3413
    file_iformat = NULL;
3414
}
3415

    
3416
/* same option as mencoder */
3417
static void opt_pass(const char *pass_str)
3418
{
3419
    int pass;
3420
    pass = atoi(pass_str);
3421
    if (pass != 1 && pass != 2) {
3422
        fprintf(stderr, "pass number can be only 1 or 2\n");
3423
        av_exit(1);
3424
    }
3425
    do_pass = pass;
3426
}
3427

    
3428
static int64_t getutime(void)
3429
{
3430
#ifdef HAVE_GETRUSAGE
3431
    struct rusage rusage;
3432

    
3433
    getrusage(RUSAGE_SELF, &rusage);
3434
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3435
#elif defined(HAVE_GETPROCESSTIMES)
3436
    HANDLE proc;
3437
    FILETIME c, e, k, u;
3438
    proc = GetCurrentProcess();
3439
    GetProcessTimes(proc, &c, &e, &k, &u);
3440
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3441
#else
3442
    return av_gettime();
3443
#endif
3444
}
3445

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

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

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

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

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

    
3521
static void opt_target(const char *arg)
3522
{
3523
    int norm = -1;
3524
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3525

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

    
3570
    if(norm < 0) {
3571
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3572
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3573
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3574
        av_exit(1);
3575
    }
3576

    
3577
    if(!strcmp(arg, "vcd")) {
3578

    
3579
        opt_video_codec("mpeg1video");
3580
        opt_audio_codec("mp2");
3581
        opt_format("vcd");
3582

    
3583
        opt_frame_size(norm ? "352x240" : "352x288");
3584
        opt_frame_rate(frame_rates[norm]);
3585
        opt_default("gop", norm ? "18" : "15");
3586

    
3587
        opt_default("b", "1150000");
3588
        opt_default("maxrate", "1150000");
3589
        opt_default("minrate", "1150000");
3590
        opt_default("bufsize", "327680"); // 40*1024*8;
3591

    
3592
        opt_default("ab", "224000");
3593
        audio_sample_rate = 44100;
3594
        audio_channels = 2;
3595

    
3596
        opt_default("packetsize", "2324");
3597
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3598

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

    
3607
        opt_video_codec("mpeg2video");
3608
        opt_audio_codec("mp2");
3609
        opt_format("svcd");
3610

    
3611
        opt_frame_size(norm ? "480x480" : "480x576");
3612
        opt_frame_rate(frame_rates[norm]);
3613
        opt_default("gop", norm ? "18" : "15");
3614

    
3615
        opt_default("b", "2040000");
3616
        opt_default("maxrate", "2516000");
3617
        opt_default("minrate", "0"); //1145000;
3618
        opt_default("bufsize", "1835008"); //224*1024*8;
3619
        opt_default("flags", "+SCAN_OFFSET");
3620

    
3621

    
3622
        opt_default("ab", "224000");
3623
        audio_sample_rate = 44100;
3624

    
3625
        opt_default("packetsize", "2324");
3626

    
3627
    } else if(!strcmp(arg, "dvd")) {
3628

    
3629
        opt_video_codec("mpeg2video");
3630
        opt_audio_codec("ac3");
3631
        opt_format("dvd");
3632

    
3633
        opt_frame_size(norm ? "720x480" : "720x576");
3634
        opt_frame_rate(frame_rates[norm]);
3635
        opt_default("gop", norm ? "18" : "15");
3636

    
3637
        opt_default("b", "6000000");
3638
        opt_default("maxrate", "9000000");
3639
        opt_default("minrate", "0"); //1500000;
3640
        opt_default("bufsize", "1835008"); //224*1024*8;
3641

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

    
3645
        opt_default("ab", "448000");
3646
        audio_sample_rate = 48000;
3647

    
3648
    } else if(!strncmp(arg, "dv", 2)) {
3649

    
3650
        opt_format("dv");
3651

    
3652
        opt_frame_size(norm ? "720x480" : "720x576");
3653
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3654
                                             (norm ? "yuv411p" : "yuv420p"));
3655
        opt_frame_rate(frame_rates[norm]);
3656

    
3657
        audio_sample_rate = 48000;
3658
        audio_channels = 2;
3659

    
3660
    } else {
3661
        fprintf(stderr, "Unknown target: %s\n", arg);
3662
        av_exit(1);
3663
    }
3664
}
3665

    
3666
static void opt_vstats_file (const char *arg)
3667
{
3668
    av_free (vstats_filename);
3669
    vstats_filename=av_strdup (arg);
3670
}
3671

    
3672
static void opt_vstats (void)
3673
{
3674
    char filename[40];
3675
    time_t today2 = time(NULL);
3676
    struct tm *today = localtime(&today2);
3677

    
3678
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3679
             today->tm_sec);
3680
    opt_vstats_file(filename);
3681
}
3682

    
3683
static int opt_bsf(const char *opt, const char *arg)
3684
{
3685
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3686
    AVBitStreamFilterContext **bsfp;
3687

    
3688
    if(!bsfc){
3689
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3690
        av_exit(1);
3691
    }
3692

    
3693
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3694
          *opt == 'a' ? &audio_bitstream_filters :
3695
                        &subtitle_bitstream_filters;
3696
    while(*bsfp)
3697
        bsfp= &(*bsfp)->next;
3698

    
3699
    *bsfp= bsfc;
3700

    
3701
    return 0;
3702
}
3703

    
3704
static int opt_preset(const char *opt, const char *arg)
3705
{
3706
    FILE *f=NULL;
3707
    char tmp[1000], tmp2[1000];
3708
    int i;
3709
    const char *base[3]= { getenv("HOME"),
3710
                           "/usr/local/share",
3711
                           "/usr/share",
3712
                         };
3713

    
3714
    for(i=!base[0]; i<3 && !f; i++){
3715
        snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3716
        f= fopen(tmp, "r");
3717
        if(!f){
3718
            char *codec_name= *opt == 'v' ? video_codec_name :
3719
                              *opt == 'a' ? audio_codec_name :
3720
                                            subtitle_codec_name;
3721
              snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3722
            f= fopen(tmp, "r");
3723
        }
3724
    }
3725

    
3726
    if(!f){
3727
        fprintf(stderr, "Preset file not found\n");
3728
        av_exit(1);
3729
    }
3730

    
3731
    while(!feof(f)){
3732
        int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3733
        if(e!=2){
3734
            fprintf(stderr, "Preset file invalid\n");
3735
            av_exit(1);
3736
        }
3737
        if(!strcmp(tmp, "acodec")){
3738
            opt_audio_codec(tmp2);
3739
        }else if(!strcmp(tmp, "vcodec")){
3740
            opt_video_codec(tmp2);
3741
        }else if(!strcmp(tmp, "scodec")){
3742
            opt_subtitle_codec(tmp2);
3743
        }else
3744
            opt_default(tmp, tmp2);
3745
    }
3746

    
3747
    fclose(f);
3748

    
3749
    return 0;
3750
}
3751

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

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

    
3841
    /* audio options */
3842
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3843
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3844
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3845
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3846
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3847
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3848
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3849
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3850
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3851
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3852
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3853
    { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
3854

    
3855
    /* subtitle options */
3856
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3857
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3858
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3859
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3860

    
3861
    /* grab options */
3862
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3863
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3864
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3865

    
3866
    /* muxer options */
3867
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3868
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3869

    
3870
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3871
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3872
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3873

    
3874
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3875
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3876
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3877

    
3878
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3879
    { NULL, },
3880
};
3881

    
3882
int main(int argc, char **argv)
3883
{
3884
    int i;
3885
    int64_t ti;
3886

    
3887
    avcodec_register_all();
3888
    avdevice_register_all();
3889
    av_register_all();
3890

    
3891
    if(isatty(STDIN_FILENO))
3892
        url_set_interrupt_cb(decode_interrupt_cb);
3893

    
3894
    for(i=0; i<CODEC_TYPE_NB; i++){
3895
        avctx_opts[i]= avcodec_alloc_context2(i);
3896
    }
3897
    avformat_opts = av_alloc_format_context();
3898
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3899

    
3900
    show_banner();
3901
    if (argc <= 1) {
3902
        show_help();
3903
        av_exit(1);
3904
    }
3905

    
3906
    /* parse options */
3907
    parse_options(argc, argv, options, opt_output_file);
3908

    
3909
    /* file converter / grab */
3910
    if (nb_output_files <= 0) {
3911
        fprintf(stderr, "Must supply at least one output file\n");
3912
        av_exit(1);
3913
    }
3914

    
3915
    if (nb_input_files == 0) {
3916
        fprintf(stderr, "Must supply at least one input file\n");
3917
        av_exit(1);
3918
    }
3919

    
3920
    ti = getutime();
3921
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3922
              stream_maps, nb_stream_maps);
3923
    ti = getutime() - ti;
3924
    if (do_benchmark) {
3925
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3926
    }
3927

    
3928
    return av_exit(0);
3929
}