Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 094d9df7

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
/* needed for usleep() */
23
#define _XOPEN_SOURCE 600
24

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

    
44
#ifdef HAVE_SYS_RESOURCE_H
45
#include <sys/types.h>
46
#include <sys/resource.h>
47
#elif defined(HAVE_GETPROCESSTIMES)
48
#include <windows.h>
49
#endif
50

    
51
#ifdef HAVE_SYS_SELECT_H
52
#include <sys/select.h>
53
#endif
54

    
55
#ifdef HAVE_TERMIOS_H
56
#include <fcntl.h>
57
#include <sys/ioctl.h>
58
#include <sys/time.h>
59
#include <termios.h>
60
#elif defined(HAVE_CONIO_H)
61
#include <conio.h>
62
#endif
63
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
64
#include <time.h>
65

    
66
#include "cmdutils.h"
67

    
68
#undef NDEBUG
69
#include <assert.h>
70

    
71
#undef exit
72

    
73
const char program_name[] = "FFmpeg";
74
const int program_birth_year = 2000;
75

    
76
/* select an input stream for an output stream */
77
typedef struct AVStreamMap {
78
    int file_index;
79
    int stream_index;
80
    int sync_file_index;
81
    int sync_stream_index;
82
} AVStreamMap;
83

    
84
/** select an input file for an output file */
85
typedef struct AVMetaDataMap {
86
    int out_file;
87
    int in_file;
88
} AVMetaDataMap;
89

    
90
static const OptionDef options[];
91

    
92
#define MAX_FILES 20
93

    
94
static AVFormatContext *input_files[MAX_FILES];
95
static int64_t input_files_ts_offset[MAX_FILES];
96
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
97
static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
98
static int nb_input_files = 0;
99
static int nb_icodecs;
100

    
101
static AVFormatContext *output_files[MAX_FILES];
102
static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
103
static int nb_output_files = 0;
104
static int nb_ocodecs;
105

    
106
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
107
static int nb_stream_maps;
108

    
109
static AVMetaDataMap meta_data_maps[MAX_FILES];
110
static int nb_meta_data_maps;
111

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

    
152
static int intra_only = 0;
153
static int audio_sample_rate = 44100;
154
static int64_t channel_layout = 0;
155
#define QSCALE_NONE -99999
156
static float audio_qscale = QSCALE_NONE;
157
static int audio_disable = 0;
158
static int audio_channels = 1;
159
static char  *audio_codec_name = NULL;
160
static int audio_codec_tag = 0;
161
static char *audio_language = NULL;
162

    
163
static int subtitle_disable = 0;
164
static char *subtitle_codec_name = NULL;
165
static char *subtitle_language = NULL;
166

    
167
static float mux_preload= 0.5;
168
static float mux_max_delay= 0.7;
169

    
170
static int64_t recording_time = INT64_MAX;
171
static int64_t start_time = 0;
172
static int64_t rec_timestamp = 0;
173
static int64_t input_ts_offset = 0;
174
static int file_overwrite = 0;
175
static char *str_title = NULL;
176
static char *str_author = NULL;
177
static char *str_copyright = NULL;
178
static char *str_comment = NULL;
179
static char *str_genre = NULL;
180
static char *str_album = NULL;
181
static int do_benchmark = 0;
182
static int do_hex_dump = 0;
183
static int do_pkt_dump = 0;
184
static int do_psnr = 0;
185
static int do_pass = 0;
186
static char *pass_logfilename_prefix = NULL;
187
static int audio_stream_copy = 0;
188
static int video_stream_copy = 0;
189
static int subtitle_stream_copy = 0;
190
static int video_sync_method= -1;
191
static int audio_sync_method= 0;
192
static float audio_drift_threshold= 0.1;
193
static int copy_ts= 0;
194
static int opt_shortest = 0;
195
static int video_global_header = 0;
196
static char *vstats_filename;
197
static FILE *vstats_file;
198
static int opt_programid = 0;
199
static int copy_initial_nonkeyframes = 0;
200

    
201
static int rate_emu = 0;
202

    
203
static int  video_channel = 0;
204
static char *video_standard;
205

    
206
static int audio_volume = 256;
207

    
208
static int exit_on_error = 0;
209
static int using_stdin = 0;
210
static int using_vhook = 0;
211
static int verbose = 1;
212
static int thread_count= 1;
213
static int q_pressed = 0;
214
static int64_t video_size = 0;
215
static int64_t audio_size = 0;
216
static int64_t extra_size = 0;
217
static int nb_frames_dup = 0;
218
static int nb_frames_drop = 0;
219
static int input_sync;
220
static uint64_t limit_filesize = 0;
221
static int force_fps = 0;
222

    
223
static int pgmyuv_compatibility_hack=0;
224
static float dts_delta_threshold = 10;
225

    
226
static unsigned int sws_flags = SWS_BICUBIC;
227

    
228
static int64_t timer_start;
229

    
230
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
231
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
232
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
233
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
234

    
235
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
236

    
237
struct AVInputStream;
238

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

    
257
    int video_crop;
258
    int topBand;             /* cropping area sizes */
259
    int leftBand;
260

    
261
    int video_pad;
262
    int padtop;              /* padding area sizes */
263
    int padbottom;
264
    int padleft;
265
    int padright;
266

    
267
    /* audio only */
268
    int audio_resample;
269
    ReSampleContext *resample; /* for audio resampling */
270
    int reformat_pair;
271
    AVAudioConvert *reformat_ctx;
272
    AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
273
    FILE *logfile;
274
} AVOutputStream;
275

    
276
typedef struct AVInputStream {
277
    int file_index;
278
    int index;
279
    AVStream *st;
280
    int discard;             /* true if stream data should be discarded */
281
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
282
    int64_t sample_index;      /* current sample */
283

    
284
    int64_t       start;     /* time when read started */
285
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
286
                                is not defined */
287
    int64_t       pts;       /* current pts */
288
    int is_start;            /* is 1 at the start and after a discontinuity */
289
} AVInputStream;
290

    
291
typedef struct AVInputFile {
292
    int eof_reached;      /* true if eof reached */
293
    int ist_index;        /* index of first stream in ist_table */
294
    int buffer_size;      /* current total buffer size */
295
    int nb_streams;       /* nb streams we are aware of */
296
} AVInputFile;
297

    
298
#ifdef HAVE_TERMIOS_H
299

    
300
/* init terminal so that we can grab keys */
301
static struct termios oldtty;
302
#endif
303

    
304
static void term_exit(void)
305
{
306
#ifdef HAVE_TERMIOS_H
307
    tcsetattr (0, TCSANOW, &oldtty);
308
#endif
309
}
310

    
311
static volatile sig_atomic_t received_sigterm = 0;
312

    
313
static void
314
sigterm_handler(int sig)
315
{
316
    received_sigterm = sig;
317
    term_exit();
318
}
319

    
320
static void term_init(void)
321
{
322
#ifdef HAVE_TERMIOS_H
323
    struct termios tty;
324

    
325
    tcgetattr (0, &tty);
326
    oldtty = tty;
327

    
328
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
329
                          |INLCR|IGNCR|ICRNL|IXON);
330
    tty.c_oflag |= OPOST;
331
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
332
    tty.c_cflag &= ~(CSIZE|PARENB);
333
    tty.c_cflag |= CS8;
334
    tty.c_cc[VMIN] = 1;
335
    tty.c_cc[VTIME] = 0;
336

    
337
    tcsetattr (0, TCSANOW, &tty);
338
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
339
#endif
340

    
341
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
342
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
343
    /*
344
    register a function to be called at normal program termination
345
    */
346
    atexit(term_exit);
347
#ifdef CONFIG_BEOS_NETSERVER
348
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
349
#endif
350
}
351

    
352
/* read a key without blocking */
353
static int read_key(void)
354
{
355
#if defined(HAVE_TERMIOS_H)
356
    int n = 1;
357
    unsigned char ch;
358
#ifndef CONFIG_BEOS_NETSERVER
359
    struct timeval tv;
360
    fd_set rfds;
361

    
362
    FD_ZERO(&rfds);
363
    FD_SET(0, &rfds);
364
    tv.tv_sec = 0;
365
    tv.tv_usec = 0;
366
    n = select(1, &rfds, NULL, NULL, &tv);
367
#endif
368
    if (n > 0) {
369
        n = read(0, &ch, 1);
370
        if (n == 1)
371
            return ch;
372

    
373
        return n;
374
    }
375
#elif defined(HAVE_CONIO_H)
376
    if(kbhit())
377
        return(getch());
378
#endif
379
    return -1;
380
}
381

    
382
static int decode_interrupt_cb(void)
383
{
384
    return q_pressed || (q_pressed = read_key() == 'q');
385
}
386

    
387
static int av_exit(int ret)
388
{
389
    int i;
390

    
391
    /* close files */
392
    for(i=0;i<nb_output_files;i++) {
393
        /* maybe av_close_output_file ??? */
394
        AVFormatContext *s = output_files[i];
395
        int j;
396
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
397
            url_fclose(s->pb);
398
        for(j=0;j<s->nb_streams;j++) {
399
            av_metadata_free(&s->streams[j]->metadata);
400
            av_free(s->streams[j]->codec);
401
            av_free(s->streams[j]);
402
        }
403
        for(j=0;j<s->nb_programs;j++) {
404
            av_metadata_free(&s->programs[j]->metadata);
405
        }
406
        for(j=0;j<s->nb_chapters;j++) {
407
            av_metadata_free(&s->chapters[j]->metadata);
408
        }
409
        av_metadata_free(&s->metadata);
410
        av_free(s);
411
    }
412
    for(i=0;i<nb_input_files;i++)
413
        av_close_input_file(input_files[i]);
414

    
415
    av_free(intra_matrix);
416
    av_free(inter_matrix);
417

    
418
    if (vstats_file)
419
        fclose(vstats_file);
420
    av_free(vstats_filename);
421

    
422
    av_free(opt_names);
423

    
424
    av_free(video_codec_name);
425
    av_free(audio_codec_name);
426
    av_free(subtitle_codec_name);
427

    
428
    av_free(video_standard);
429

    
430
#ifdef CONFIG_POWERPC_PERF
431
    void powerpc_display_perf_report(void);
432
    powerpc_display_perf_report();
433
#endif /* CONFIG_POWERPC_PERF */
434

    
435
    if (received_sigterm) {
436
        fprintf(stderr,
437
            "Received signal %d: terminating.\n",
438
            (int) received_sigterm);
439
        exit (255);
440
    }
441

    
442
    exit(ret); /* not all OS-es handle main() return value */
443
    return ret;
444
}
445

    
446
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
447
{
448
    int i, err;
449
    AVFormatContext *ic;
450
    int nopts = 0;
451

    
452
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
453
    if (err < 0)
454
        return err;
455
    /* copy stream format */
456
    s->nb_streams = ic->nb_streams;
457
    for(i=0;i<ic->nb_streams;i++) {
458
        AVStream *st;
459

    
460
        // FIXME: a more elegant solution is needed
461
        st = av_mallocz(sizeof(AVStream));
462
        memcpy(st, ic->streams[i], sizeof(AVStream));
463
        st->codec = avcodec_alloc_context();
464
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
465
        s->streams[i] = st;
466

    
467
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
468
            st->stream_copy = 1;
469
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
470
            st->stream_copy = 1;
471

    
472
        if(!st->codec->thread_count)
473
            st->codec->thread_count = 1;
474
        if(st->codec->thread_count>1)
475
            avcodec_thread_init(st->codec, st->codec->thread_count);
476

    
477
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
478
            nopts = 1;
479
    }
480

    
481
    if (!nopts)
482
        s->timestamp = av_gettime();
483

    
484
    av_close_input_file(ic);
485
    return 0;
486
}
487

    
488
static double
489
get_sync_ipts(const AVOutputStream *ost)
490
{
491
    const AVInputStream *ist = ost->sync_ist;
492
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
493
}
494

    
495
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
496
    int ret;
497

    
498
    while(bsfc){
499
        AVPacket new_pkt= *pkt;
500
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
501
                                          &new_pkt.data, &new_pkt.size,
502
                                          pkt->data, pkt->size,
503
                                          pkt->flags & PKT_FLAG_KEY);
504
        if(a>0){
505
            av_free_packet(pkt);
506
            new_pkt.destruct= av_destruct_packet;
507
        } else if(a<0){
508
            fprintf(stderr, "%s failed for stream %d, codec %s",
509
                    bsfc->filter->name, pkt->stream_index,
510
                    avctx->codec ? avctx->codec->name : "copy");
511
            print_error("", a);
512
            if (exit_on_error)
513
                av_exit(1);
514
        }
515
        *pkt= new_pkt;
516

    
517
        bsfc= bsfc->next;
518
    }
519

    
520
    ret= av_interleaved_write_frame(s, pkt);
521
    if(ret < 0){
522
        print_error("av_interleaved_write_frame()", ret);
523
        av_exit(1);
524
    }
525
}
526

    
527
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
528

    
529
static void do_audio_out(AVFormatContext *s,
530
                         AVOutputStream *ost,
531
                         AVInputStream *ist,
532
                         unsigned char *buf, int size)
533
{
534
    uint8_t *buftmp;
535
    static uint8_t *audio_buf = NULL;
536
    static uint8_t *audio_out = NULL;
537
    static uint8_t *audio_out2 = NULL;
538
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
539

    
540
    int size_out, frame_bytes, ret;
541
    AVCodecContext *enc= ost->st->codec;
542
    AVCodecContext *dec= ist->st->codec;
543
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
544
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
545

    
546
    /* SC: dynamic allocation of buffers */
547
    if (!audio_buf)
548
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
549
    if (!audio_out)
550
        audio_out = av_malloc(audio_out_size);
551
    if (!audio_buf || !audio_out)
552
        return;               /* Should signal an error ! */
553

    
554
    if (enc->channels != dec->channels)
555
        ost->audio_resample = 1;
556

    
557
    if (ost->audio_resample && !ost->resample) {
558
        if (dec->sample_fmt != SAMPLE_FMT_S16) {
559
            fprintf(stderr, "Audio resampler only works with 16 bits per sample, patch welcome.\n");
560
            av_exit(1);
561
        }
562
        ost->resample = audio_resample_init(enc->channels,    dec->channels,
563
                                            enc->sample_rate, dec->sample_rate);
564
        if (!ost->resample) {
565
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
566
                    dec->channels, dec->sample_rate,
567
                    enc->channels, enc->sample_rate);
568
            av_exit(1);
569
        }
570
    }
571

    
572
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
573
    if (dec->sample_fmt!=enc->sample_fmt &&
574
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
575
        if (!audio_out2)
576
            audio_out2 = av_malloc(audio_out_size);
577
        if (!audio_out2)
578
            av_exit(1);
579
        if (ost->reformat_ctx)
580
            av_audio_convert_free(ost->reformat_ctx);
581
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
582
                                                   dec->sample_fmt, 1, NULL, 0);
583
        if (!ost->reformat_ctx) {
584
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
585
                avcodec_get_sample_fmt_name(dec->sample_fmt),
586
                avcodec_get_sample_fmt_name(enc->sample_fmt));
587
            av_exit(1);
588
        }
589
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
590
    }
591

    
592
    if(audio_sync_method){
593
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
594
                - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
595
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
596
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
597

    
598
        //FIXME resample delay
599
        if(fabs(delta) > 50){
600
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
601
                if(byte_delta < 0){
602
                    byte_delta= FFMAX(byte_delta, -size);
603
                    size += byte_delta;
604
                    buf  -= byte_delta;
605
                    if(verbose > 2)
606
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
607
                    if(!size)
608
                        return;
609
                    ist->is_start=0;
610
                }else{
611
                    static uint8_t *input_tmp= NULL;
612
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
613

    
614
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
615
                        ist->is_start=0;
616
                    else
617
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
618

    
619
                    memset(input_tmp, 0, byte_delta);
620
                    memcpy(input_tmp + byte_delta, buf, size);
621
                    buf= input_tmp;
622
                    size += byte_delta;
623
                    if(verbose > 2)
624
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
625
                }
626
            }else if(audio_sync_method>1){
627
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
628
                assert(ost->audio_resample);
629
                if(verbose > 2)
630
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
631
//                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));
632
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
633
            }
634
        }
635
    }else
636
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
637
                        - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
638

    
639
    if (ost->audio_resample) {
640
        buftmp = audio_buf;
641
        size_out = audio_resample(ost->resample,
642
                                  (short *)buftmp, (short *)buf,
643
                                  size / (ist->st->codec->channels * isize));
644
        size_out = size_out * enc->channels * osize;
645
    } else {
646
        buftmp = buf;
647
        size_out = size;
648
    }
649

    
650
    if (dec->sample_fmt!=enc->sample_fmt) {
651
        const void *ibuf[6]= {buftmp};
652
        void *obuf[6]= {audio_out2};
653
        int istride[6]= {isize};
654
        int ostride[6]= {osize};
655
        int len= size_out/istride[0];
656
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
657
            printf("av_audio_convert() failed\n");
658
            if (exit_on_error)
659
                av_exit(1);
660
            return;
661
        }
662
        buftmp = audio_out2;
663
        size_out = len*osize;
664
    }
665

    
666
    /* now encode as many frames as possible */
667
    if (enc->frame_size > 1) {
668
        /* output resampled raw samples */
669
        if (av_fifo_realloc2(&ost->fifo, av_fifo_size(&ost->fifo) + size_out) < 0) {
670
            fprintf(stderr, "av_fifo_realloc2() failed\n");
671
            av_exit(1);
672
        }
673
        av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
674

    
675
        frame_bytes = enc->frame_size * osize * enc->channels;
676

    
677
        while (av_fifo_size(&ost->fifo) >= frame_bytes) {
678
            AVPacket pkt;
679
            av_init_packet(&pkt);
680

    
681
            av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
682

    
683
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
684

    
685
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
686
                                       (short *)audio_buf);
687
            audio_size += ret;
688
            pkt.stream_index= ost->index;
689
            pkt.data= audio_out;
690
            pkt.size= ret;
691
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
692
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
693
            pkt.flags |= PKT_FLAG_KEY;
694
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
695

    
696
            ost->sync_opts += enc->frame_size;
697
        }
698
    } else {
699
        AVPacket pkt;
700
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
701
        av_init_packet(&pkt);
702

    
703
        ost->sync_opts += size_out / (osize * enc->channels);
704

    
705
        /* output a pcm frame */
706
        /* determine the size of the coded buffer */
707
        size_out /= osize;
708
        if (coded_bps)
709
            size_out *= coded_bps;
710

    
711
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
712
        ret = avcodec_encode_audio(enc, audio_out, size_out,
713
                                   (short *)buftmp);
714
        audio_size += ret;
715
        pkt.stream_index= ost->index;
716
        pkt.data= audio_out;
717
        pkt.size= ret;
718
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
719
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
720
        pkt.flags |= PKT_FLAG_KEY;
721
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
722
    }
723
}
724

    
725
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
726
{
727
    AVCodecContext *dec;
728
    AVPicture *picture2;
729
    AVPicture picture_tmp;
730
    uint8_t *buf = 0;
731

    
732
    dec = ist->st->codec;
733

    
734
    /* deinterlace : must be done before any resize */
735
    if (do_deinterlace || using_vhook) {
736
        int size;
737

    
738
        /* create temporary picture */
739
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
740
        buf = av_malloc(size);
741
        if (!buf)
742
            return;
743

    
744
        picture2 = &picture_tmp;
745
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
746

    
747
        if (do_deinterlace){
748
            if(avpicture_deinterlace(picture2, picture,
749
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
750
                /* if error, do not deinterlace */
751
                fprintf(stderr, "Deinterlacing failed\n");
752
                av_free(buf);
753
                buf = NULL;
754
                picture2 = picture;
755
            }
756
        } else {
757
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
758
        }
759
    } else {
760
        picture2 = picture;
761
    }
762

    
763
    if (ENABLE_VHOOK)
764
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
765
                           1000000 * ist->pts / AV_TIME_BASE);
766

    
767
    if (picture != picture2)
768
        *picture = *picture2;
769
    *bufp = buf;
770
}
771

    
772
/* we begin to correct av delay at this threshold */
773
#define AV_DELAY_MAX 0.100
774

    
775
static void do_subtitle_out(AVFormatContext *s,
776
                            AVOutputStream *ost,
777
                            AVInputStream *ist,
778
                            AVSubtitle *sub,
779
                            int64_t pts)
780
{
781
    static uint8_t *subtitle_out = NULL;
782
    int subtitle_out_max_size = 65536;
783
    int subtitle_out_size, nb, i;
784
    AVCodecContext *enc;
785
    AVPacket pkt;
786

    
787
    if (pts == AV_NOPTS_VALUE) {
788
        fprintf(stderr, "Subtitle packets must have a pts\n");
789
        if (exit_on_error)
790
            av_exit(1);
791
        return;
792
    }
793

    
794
    enc = ost->st->codec;
795

    
796
    if (!subtitle_out) {
797
        subtitle_out = av_malloc(subtitle_out_max_size);
798
    }
799

    
800
    /* Note: DVB subtitle need one packet to draw them and one other
801
       packet to clear them */
802
    /* XXX: signal it in the codec context ? */
803
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
804
        nb = 2;
805
    else
806
        nb = 1;
807

    
808
    for(i = 0; i < nb; i++) {
809
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
810
                                                    subtitle_out_max_size, sub);
811

    
812
        av_init_packet(&pkt);
813
        pkt.stream_index = ost->index;
814
        pkt.data = subtitle_out;
815
        pkt.size = subtitle_out_size;
816
        pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
817
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
818
            /* XXX: the pts correction is handled here. Maybe handling
819
               it in the codec would be better */
820
            if (i == 0)
821
                pkt.pts += 90 * sub->start_display_time;
822
            else
823
                pkt.pts += 90 * sub->end_display_time;
824
        }
825
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
826
    }
827
}
828

    
829
static int bit_buffer_size= 1024*256;
830
static uint8_t *bit_buffer= NULL;
831

    
832
static void do_video_out(AVFormatContext *s,
833
                         AVOutputStream *ost,
834
                         AVInputStream *ist,
835
                         AVFrame *in_picture,
836
                         int *frame_size)
837
{
838
    int nb_frames, i, ret;
839
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
840
    AVFrame picture_crop_temp, picture_pad_temp;
841
    AVCodecContext *enc, *dec;
842

    
843
    avcodec_get_frame_defaults(&picture_crop_temp);
844
    avcodec_get_frame_defaults(&picture_pad_temp);
845

    
846
    enc = ost->st->codec;
847
    dec = ist->st->codec;
848

    
849
    /* by default, we output a single frame */
850
    nb_frames = 1;
851

    
852
    *frame_size = 0;
853

    
854
    if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
855
        double vdelta;
856
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
857
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
858
        if (vdelta < -1.1)
859
            nb_frames = 0;
860
        else if (video_sync_method == 2)
861
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
862
        else if (vdelta > 1.1)
863
            nb_frames = lrintf(vdelta);
864
//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);
865
        if (nb_frames == 0){
866
            ++nb_frames_drop;
867
            if (verbose>2)
868
                fprintf(stderr, "*** drop!\n");
869
        }else if (nb_frames > 1) {
870
            nb_frames_dup += nb_frames;
871
            if (verbose>2)
872
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
873
        }
874
    }else
875
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
876

    
877
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
878
    if (nb_frames <= 0)
879
        return;
880

    
881
    if (ost->video_crop) {
882
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
883
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
884
            if (exit_on_error)
885
                av_exit(1);
886
            return;
887
        }
888
        formatted_picture = &picture_crop_temp;
889
    } else {
890
        formatted_picture = in_picture;
891
    }
892

    
893
    final_picture = formatted_picture;
894
    padding_src = formatted_picture;
895
    resampling_dst = &ost->pict_tmp;
896
    if (ost->video_pad) {
897
        final_picture = &ost->pict_tmp;
898
        if (ost->video_resample) {
899
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
900
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
901
                if (exit_on_error)
902
                    av_exit(1);
903
                return;
904
            }
905
            resampling_dst = &picture_pad_temp;
906
        }
907
    }
908

    
909
    if (ost->video_resample) {
910
        padding_src = NULL;
911
        final_picture = &ost->pict_tmp;
912
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
913
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
914
    }
915

    
916
    if (ost->video_pad) {
917
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
918
                enc->height, enc->width, enc->pix_fmt,
919
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
920
    }
921

    
922
    /* duplicates frame if needed */
923
    for(i=0;i<nb_frames;i++) {
924
        AVPacket pkt;
925
        av_init_packet(&pkt);
926
        pkt.stream_index= ost->index;
927

    
928
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
929
            /* raw pictures are written as AVPicture structure to
930
               avoid any copies. We support temorarily the older
931
               method. */
932
            AVFrame* old_frame = enc->coded_frame;
933
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
934
            pkt.data= (uint8_t *)final_picture;
935
            pkt.size=  sizeof(AVPicture);
936
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
937
            pkt.flags |= PKT_FLAG_KEY;
938

    
939
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
940
            enc->coded_frame = old_frame;
941
        } else {
942
            AVFrame big_picture;
943

    
944
            big_picture= *final_picture;
945
            /* better than nothing: use input picture interlaced
946
               settings */
947
            big_picture.interlaced_frame = in_picture->interlaced_frame;
948
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
949
                if(top_field_first == -1)
950
                    big_picture.top_field_first = in_picture->top_field_first;
951
                else
952
                    big_picture.top_field_first = top_field_first;
953
            }
954

    
955
            /* handles sameq here. This is not correct because it may
956
               not be a global option */
957
            if (same_quality) {
958
                big_picture.quality = ist->st->quality;
959
            }else
960
                big_picture.quality = ost->st->quality;
961
            if(!me_threshold)
962
                big_picture.pict_type = 0;
963
//            big_picture.pts = AV_NOPTS_VALUE;
964
            big_picture.pts= ost->sync_opts;
965
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
966
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
967
            ret = avcodec_encode_video(enc,
968
                                       bit_buffer, bit_buffer_size,
969
                                       &big_picture);
970
            if (ret == -1) {
971
                fprintf(stderr, "Video encoding failed\n");
972
                av_exit(1);
973
            }
974
            //enc->frame_number = enc->real_pict_num;
975
            if(ret>0){
976
                pkt.data= bit_buffer;
977
                pkt.size= ret;
978
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
979
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
980
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
981
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
982
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
983

    
984
                if(enc->coded_frame->key_frame)
985
                    pkt.flags |= PKT_FLAG_KEY;
986
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
987
                *frame_size = ret;
988
                video_size += ret;
989
                //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
990
                //        enc->frame_number-1, enc->real_pict_num, ret,
991
                //        enc->pict_type);
992
                /* if two pass, output log */
993
                if (ost->logfile && enc->stats_out) {
994
                    fprintf(ost->logfile, "%s", enc->stats_out);
995
                }
996
            }
997
        }
998
        ost->sync_opts++;
999
        ost->frame_number++;
1000
    }
1001
}
1002

    
1003
static double psnr(double d){
1004
    return -10.0*log(d)/log(10.0);
1005
}
1006

    
1007
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1008
                           int frame_size)
1009
{
1010
    AVCodecContext *enc;
1011
    int frame_number;
1012
    double ti1, bitrate, avg_bitrate;
1013

    
1014
    /* this is executed just the first time do_video_stats is called */
1015
    if (!vstats_file) {
1016
        vstats_file = fopen(vstats_filename, "w");
1017
        if (!vstats_file) {
1018
            perror("fopen");
1019
            av_exit(1);
1020
        }
1021
    }
1022

    
1023
    enc = ost->st->codec;
1024
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1025
        frame_number = ost->frame_number;
1026
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1027
        if (enc->flags&CODEC_FLAG_PSNR)
1028
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1029

    
1030
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1031
        /* compute pts value */
1032
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1033
        if (ti1 < 0.01)
1034
            ti1 = 0.01;
1035

    
1036
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1037
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1038
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1039
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1040
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1041
    }
1042
}
1043

    
1044
static void print_report(AVFormatContext **output_files,
1045
                         AVOutputStream **ost_table, int nb_ostreams,
1046
                         int is_last_report)
1047
{
1048
    char buf[1024];
1049
    AVOutputStream *ost;
1050
    AVFormatContext *oc, *os;
1051
    int64_t total_size;
1052
    AVCodecContext *enc;
1053
    int frame_number, vid, i;
1054
    double bitrate, ti1, pts;
1055
    static int64_t last_time = -1;
1056
    static int qp_histogram[52];
1057

    
1058
    if (!is_last_report) {
1059
        int64_t cur_time;
1060
        /* display the report every 0.5 seconds */
1061
        cur_time = av_gettime();
1062
        if (last_time == -1) {
1063
            last_time = cur_time;
1064
            return;
1065
        }
1066
        if ((cur_time - last_time) < 500000)
1067
            return;
1068
        last_time = cur_time;
1069
    }
1070

    
1071

    
1072
    oc = output_files[0];
1073

    
1074
    total_size = url_fsize(oc->pb);
1075
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1076
        total_size= url_ftell(oc->pb);
1077

    
1078
    buf[0] = '\0';
1079
    ti1 = 1e10;
1080
    vid = 0;
1081
    for(i=0;i<nb_ostreams;i++) {
1082
        ost = ost_table[i];
1083
        os = output_files[ost->file_index];
1084
        enc = ost->st->codec;
1085
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1086
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1087
                     !ost->st->stream_copy ?
1088
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1089
        }
1090
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1091
            float t = (av_gettime()-timer_start) / 1000000.0;
1092

    
1093
            frame_number = ost->frame_number;
1094
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1095
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1096
                     !ost->st->stream_copy ?
1097
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1098
            if(is_last_report)
1099
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1100
            if(qp_hist){
1101
                int j;
1102
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1103
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1104
                    qp_histogram[qp]++;
1105
                for(j=0; j<32; j++)
1106
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1107
            }
1108
            if (enc->flags&CODEC_FLAG_PSNR){
1109
                int j;
1110
                double error, error_sum=0;
1111
                double scale, scale_sum=0;
1112
                char type[3]= {'Y','U','V'};
1113
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1114
                for(j=0; j<3; j++){
1115
                    if(is_last_report){
1116
                        error= enc->error[j];
1117
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1118
                    }else{
1119
                        error= enc->coded_frame->error[j];
1120
                        scale= enc->width*enc->height*255.0*255.0;
1121
                    }
1122
                    if(j) scale/=4;
1123
                    error_sum += error;
1124
                    scale_sum += scale;
1125
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1126
                }
1127
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1128
            }
1129
            vid = 1;
1130
        }
1131
        /* compute min output value */
1132
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1133
        if ((pts < ti1) && (pts > 0))
1134
            ti1 = pts;
1135
    }
1136
    if (ti1 < 0.01)
1137
        ti1 = 0.01;
1138

    
1139
    if (verbose || is_last_report) {
1140
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1141

    
1142
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1143
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1144
            (double)total_size / 1024, ti1, bitrate);
1145

    
1146
        if (verbose > 1)
1147
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1148
                  nb_frames_dup, nb_frames_drop);
1149

    
1150
        if (verbose >= 0)
1151
            fprintf(stderr, "%s    \r", buf);
1152

    
1153
        fflush(stderr);
1154
    }
1155

    
1156
    if (is_last_report && verbose >= 0){
1157
        int64_t raw= audio_size + video_size + extra_size;
1158
        fprintf(stderr, "\n");
1159
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1160
                video_size/1024.0,
1161
                audio_size/1024.0,
1162
                extra_size/1024.0,
1163
                100.0*(total_size - raw)/raw
1164
        );
1165
    }
1166
}
1167

    
1168
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1169
static int output_packet(AVInputStream *ist, int ist_index,
1170
                         AVOutputStream **ost_table, int nb_ostreams,
1171
                         const AVPacket *pkt)
1172
{
1173
    AVFormatContext *os;
1174
    AVOutputStream *ost;
1175
    uint8_t *ptr;
1176
    int len, ret, i;
1177
    uint8_t *data_buf;
1178
    int data_size, got_picture;
1179
    AVFrame picture;
1180
    void *buffer_to_free;
1181
    static unsigned int samples_size= 0;
1182
    static short *samples= NULL;
1183
    AVSubtitle subtitle, *subtitle_to_free;
1184
    int got_subtitle;
1185

    
1186
    if(ist->next_pts == AV_NOPTS_VALUE)
1187
        ist->next_pts= ist->pts;
1188

    
1189
    if (pkt == NULL) {
1190
        /* EOF handling */
1191
        ptr = NULL;
1192
        len = 0;
1193
        goto handle_eof;
1194
    }
1195

    
1196
    if(pkt->dts != AV_NOPTS_VALUE)
1197
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1198

    
1199
    len = pkt->size;
1200
    ptr = pkt->data;
1201

    
1202
    //while we have more to decode or while the decoder did output something on EOF
1203
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1204
    handle_eof:
1205
        ist->pts= ist->next_pts;
1206

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

    
1210
        /* decode the packet if needed */
1211
        data_buf = NULL; /* fail safe */
1212
        data_size = 0;
1213
        subtitle_to_free = NULL;
1214
        if (ist->decoding_needed) {
1215
            switch(ist->st->codec->codec_type) {
1216
            case CODEC_TYPE_AUDIO:{
1217
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1218
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1219
                    av_free(samples);
1220
                    samples= av_malloc(samples_size);
1221
                }
1222
                data_size= samples_size;
1223
                    /* XXX: could avoid copy if PCM 16 bits with same
1224
                       endianness as CPU */
1225
                ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1226
                                           ptr, len);
1227
                if (ret < 0)
1228
                    goto fail_decode;
1229
                ptr += ret;
1230
                len -= ret;
1231
                /* Some bug in mpeg audio decoder gives */
1232
                /* data_size < 0, it seems they are overflows */
1233
                if (data_size <= 0) {
1234
                    /* no audio frame */
1235
                    continue;
1236
                }
1237
                data_buf = (uint8_t *)samples;
1238
                ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1239
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1240
                break;}
1241
            case CODEC_TYPE_VIDEO:
1242
                    data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1243
                    /* XXX: allocate picture correctly */
1244
                    avcodec_get_frame_defaults(&picture);
1245

    
1246
                    ret = avcodec_decode_video(ist->st->codec,
1247
                                               &picture, &got_picture, ptr, len);
1248
                    ist->st->quality= picture.quality;
1249
                    if (ret < 0)
1250
                        goto fail_decode;
1251
                    if (!got_picture) {
1252
                        /* no picture yet */
1253
                        goto discard_packet;
1254
                    }
1255
                    if (ist->st->codec->time_base.num != 0) {
1256
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1257
                                          ist->st->codec->time_base.num) /
1258
                            ist->st->codec->time_base.den;
1259
                    }
1260
                    len = 0;
1261
                    break;
1262
            case CODEC_TYPE_SUBTITLE:
1263
                ret = avcodec_decode_subtitle(ist->st->codec,
1264
                                              &subtitle, &got_subtitle, ptr, len);
1265
                if (ret < 0)
1266
                    goto fail_decode;
1267
                if (!got_subtitle) {
1268
                    goto discard_packet;
1269
                }
1270
                subtitle_to_free = &subtitle;
1271
                len = 0;
1272
                break;
1273
            default:
1274
                goto fail_decode;
1275
            }
1276
        } else {
1277
            switch(ist->st->codec->codec_type) {
1278
            case CODEC_TYPE_AUDIO:
1279
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1280
                    ist->st->codec->sample_rate;
1281
                break;
1282
            case CODEC_TYPE_VIDEO:
1283
                if (ist->st->codec->time_base.num != 0) {
1284
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1285
                                      ist->st->codec->time_base.num) /
1286
                        ist->st->codec->time_base.den;
1287
                }
1288
                break;
1289
            }
1290
            data_buf = ptr;
1291
            data_size = len;
1292
            ret = len;
1293
            len = 0;
1294
        }
1295

    
1296
        buffer_to_free = NULL;
1297
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1298
            pre_process_video_frame(ist, (AVPicture *)&picture,
1299
                                    &buffer_to_free);
1300
        }
1301

    
1302
        // preprocess audio (volume)
1303
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1304
            if (audio_volume != 256) {
1305
                short *volp;
1306
                volp = samples;
1307
                for(i=0;i<(data_size / sizeof(short));i++) {
1308
                    int v = ((*volp) * audio_volume + 128) >> 8;
1309
                    if (v < -32768) v = -32768;
1310
                    if (v >  32767) v = 32767;
1311
                    *volp++ = v;
1312
                }
1313
            }
1314
        }
1315

    
1316
        /* frame rate emulation */
1317
        if (rate_emu) {
1318
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1319
            int64_t now = av_gettime() - ist->start;
1320
            if (pts > now)
1321
                usleep(pts - now);
1322
        }
1323

    
1324
        /* if output time reached then transcode raw format,
1325
           encode packets and output them */
1326
        if (start_time == 0 || ist->pts >= start_time)
1327
            for(i=0;i<nb_ostreams;i++) {
1328
                int frame_size;
1329

    
1330
                ost = ost_table[i];
1331
                if (ost->source_index == ist_index) {
1332
                    os = output_files[ost->file_index];
1333

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

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

    
1365
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1366
                            continue;
1367

    
1368
                        /* no reencoding needed : output the packet directly */
1369
                        /* force the input stream PTS */
1370

    
1371
                        avcodec_get_frame_defaults(&avframe);
1372
                        ost->st->codec->coded_frame= &avframe;
1373
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1374

    
1375
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1376
                            audio_size += data_size;
1377
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1378
                            video_size += data_size;
1379
                            ost->sync_opts++;
1380
                        }
1381

    
1382
                        opkt.stream_index= ost->index;
1383
                        if(pkt->pts != AV_NOPTS_VALUE)
1384
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1385
                        else
1386
                            opkt.pts= AV_NOPTS_VALUE;
1387

    
1388
                        if (pkt->dts == AV_NOPTS_VALUE)
1389
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1390
                        else
1391
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1392

    
1393
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1394
                        opkt.flags= pkt->flags;
1395

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

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

    
1426
        for(i=0;i<nb_ostreams;i++) {
1427
            ost = ost_table[i];
1428
            if (ost->source_index == ist_index) {
1429
                AVCodecContext *enc= ost->st->codec;
1430
                os = output_files[ost->file_index];
1431

    
1432
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1433
                    continue;
1434
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1435
                    continue;
1436

    
1437
                if (ost->encoding_needed) {
1438
                    for(;;) {
1439
                        AVPacket pkt;
1440
                        int fifo_bytes;
1441
                        av_init_packet(&pkt);
1442
                        pkt.stream_index= ost->index;
1443

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

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

    
1488
    return 0;
1489
 fail_decode:
1490
    return -1;
1491
}
1492

    
1493
static void print_sdp(AVFormatContext **avc, int n)
1494
{
1495
    char sdp[2048];
1496

    
1497
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1498
    printf("SDP:\n%s\n", sdp);
1499
    fflush(stdout);
1500
}
1501

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

    
1525
    return -1;
1526
}
1527

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

    
1546
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1547
    if (!file_table)
1548
        goto fail;
1549

    
1550
    /* input stream init */
1551
    j = 0;
1552
    for(i=0;i<nb_input_files;i++) {
1553
        is = input_files[i];
1554
        file_table[i].ist_index = j;
1555
        file_table[i].nb_streams = is->nb_streams;
1556
        j += is->nb_streams;
1557
    }
1558
    nb_istreams = j;
1559

    
1560
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1561
    if (!ist_table)
1562
        goto fail;
1563

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

    
1581
            if (rate_emu) {
1582
                ist->start = av_gettime();
1583
            }
1584
        }
1585
    }
1586

    
1587
    /* output stream init */
1588
    nb_ostreams = 0;
1589
    for(i=0;i<nb_output_files;i++) {
1590
        os = output_files[i];
1591
        if (!os->nb_streams) {
1592
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1593
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1594
            av_exit(1);
1595
        }
1596
        nb_ostreams += os->nb_streams;
1597
    }
1598
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1599
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1600
        av_exit(1);
1601
    }
1602

    
1603
    /* Sanity check the mapping args -- do the input files & streams exist? */
1604
    for(i=0;i<nb_stream_maps;i++) {
1605
        int fi = stream_maps[i].file_index;
1606
        int si = stream_maps[i].stream_index;
1607

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

    
1622
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1623
    if (!ost_table)
1624
        goto fail;
1625
    for(i=0;i<nb_ostreams;i++) {
1626
        ost = av_mallocz(sizeof(AVOutputStream));
1627
        if (!ost)
1628
            goto fail;
1629
        ost_table[i] = ost;
1630
    }
1631

    
1632
    n = 0;
1633
    for(k=0;k<nb_output_files;k++) {
1634
        os = output_files[k];
1635
        for(i=0;i<os->nb_streams;i++,n++) {
1636
            int found;
1637
            ost = ost_table[n];
1638
            ost->file_index = k;
1639
            ost->index = i;
1640
            ost->st = os->streams[i];
1641
            if (nb_stream_maps > 0) {
1642
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1643
                    stream_maps[n].stream_index;
1644

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

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

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

    
1705
    /* for each output stream, we compute the right encoding parameters */
1706
    for(i=0;i<nb_ostreams;i++) {
1707
        ost = ost_table[i];
1708
        os = output_files[ost->file_index];
1709
        ist = ist_table[ost->source_index];
1710

    
1711
        codec = ost->st->codec;
1712
        icodec = ist->st->codec;
1713

    
1714
        if (!ost->st->language[0])
1715
            av_strlcpy(ost->st->language, ist->st->language,
1716
                       sizeof(ost->st->language));
1717

    
1718
        ost->st->disposition = ist->st->disposition;
1719

    
1720
        if (ost->st->stream_copy) {
1721
            /* if stream_copy is selected, no need to decode or encode */
1722
            codec->codec_id = icodec->codec_id;
1723
            codec->codec_type = icodec->codec_type;
1724

    
1725
            if(!codec->codec_tag){
1726
                if(   !os->oformat->codec_tag
1727
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1728
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1729
                    codec->codec_tag = icodec->codec_tag;
1730
            }
1731

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

    
1848
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1849
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1850
                         i);
1851
                if (codec->flags & CODEC_FLAG_PASS1) {
1852
                    f = fopen(logfilename, "w");
1853
                    if (!f) {
1854
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1855
                        av_exit(1);
1856
                    }
1857
                    ost->logfile = f;
1858
                } else {
1859
                    /* read the log file */
1860
                    f = fopen(logfilename, "r");
1861
                    if (!f) {
1862
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1863
                        av_exit(1);
1864
                    }
1865
                    fseek(f, 0, SEEK_END);
1866
                    size = ftell(f);
1867
                    fseek(f, 0, SEEK_SET);
1868
                    logbuffer = av_malloc(size + 1);
1869
                    if (!logbuffer) {
1870
                        fprintf(stderr, "Could not allocate log buffer\n");
1871
                        av_exit(1);
1872
                    }
1873
                    size = fread(logbuffer, 1, size, f);
1874
                    fclose(f);
1875
                    logbuffer[size] = '\0';
1876
                    codec->stats_in = logbuffer;
1877
                }
1878
            }
1879
        }
1880
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1881
            int size= codec->width * codec->height;
1882
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1883
        }
1884
    }
1885

    
1886
    if (!bit_buffer)
1887
        bit_buffer = av_malloc(bit_buffer_size);
1888
    if (!bit_buffer)
1889
        goto fail;
1890

    
1891
    /* dump the file output parameters - cannot be done before in case
1892
       of stream copy */
1893
    for(i=0;i<nb_output_files;i++) {
1894
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1895
    }
1896

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

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

    
1936
    /* open each decoder */
1937
    for(i=0;i<nb_istreams;i++) {
1938
        ist = ist_table[i];
1939
        if (ist->decoding_needed) {
1940
            AVCodec *codec = input_codecs[i];
1941
            if (!codec)
1942
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
1943
            if (!codec) {
1944
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1945
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1946
                av_exit(1);
1947
            }
1948
            if (avcodec_open(ist->st->codec, codec) < 0) {
1949
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1950
                        ist->file_index, ist->index);
1951
                av_exit(1);
1952
            }
1953
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1954
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1955
        }
1956
    }
1957

    
1958
    /* init pts */
1959
    for(i=0;i<nb_istreams;i++) {
1960
        ist = ist_table[i];
1961
        is = input_files[ist->file_index];
1962
        ist->pts = 0;
1963
        ist->next_pts = AV_NOPTS_VALUE;
1964
        ist->is_start = 1;
1965
    }
1966

    
1967
    /* set meta data information from input file if required */
1968
    for (i=0;i<nb_meta_data_maps;i++) {
1969
        AVFormatContext *out_file;
1970
        AVFormatContext *in_file;
1971

    
1972
        int out_file_index = meta_data_maps[i].out_file;
1973
        int in_file_index = meta_data_maps[i].in_file;
1974
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1975
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1976
            ret = AVERROR(EINVAL);
1977
            goto fail;
1978
        }
1979
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1980
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1981
            ret = AVERROR(EINVAL);
1982
            goto fail;
1983
        }
1984

    
1985
        out_file = output_files[out_file_index];
1986
        in_file = input_files[in_file_index];
1987

    
1988
        strcpy(out_file->title, in_file->title);
1989
        strcpy(out_file->author, in_file->author);
1990
        strcpy(out_file->copyright, in_file->copyright);
1991
        strcpy(out_file->comment, in_file->comment);
1992
        strcpy(out_file->album, in_file->album);
1993
        out_file->year = in_file->year;
1994
        out_file->track = in_file->track;
1995
        strcpy(out_file->genre, in_file->genre);
1996
    }
1997

    
1998
    /* open files and write file headers */
1999
    for(i=0;i<nb_output_files;i++) {
2000
        os = output_files[i];
2001
        if (av_write_header(os) < 0) {
2002
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
2003
            ret = AVERROR(EINVAL);
2004
            goto fail;
2005
        }
2006
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2007
            want_sdp = 0;
2008
        }
2009
    }
2010
    if (want_sdp) {
2011
        print_sdp(output_files, nb_output_files);
2012
    }
2013

    
2014
    if (!using_stdin && verbose >= 0) {
2015
        fprintf(stderr, "Press [q] to stop encoding\n");
2016
        url_set_interrupt_cb(decode_interrupt_cb);
2017
    }
2018
    term_init();
2019

    
2020
    key = -1;
2021
    timer_start = av_gettime();
2022

    
2023
    for(; received_sigterm == 0;) {
2024
        int file_index, ist_index;
2025
        AVPacket pkt;
2026
        double ipts_min;
2027
        double opts_min;
2028

    
2029
    redo:
2030
        ipts_min= 1e100;
2031
        opts_min= 1e100;
2032
        /* if 'q' pressed, exits */
2033
        if (!using_stdin) {
2034
            if (q_pressed)
2035
                break;
2036
            /* read_key() returns 0 on EOF */
2037
            key = read_key();
2038
            if (key == 'q')
2039
                break;
2040
        }
2041

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

    
2075
        /* finish if recording time exhausted */
2076
        if (opts_min >= (recording_time / 1000000.0))
2077
            break;
2078

    
2079
        /* finish if limit size exhausted */
2080
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2081
            break;
2082

    
2083
        /* read a frame from it and output it in the fifo */
2084
        is = input_files[file_index];
2085
        if (av_read_frame(is, &pkt) < 0) {
2086
            file_table[file_index].eof_reached = 1;
2087
            if (opt_shortest)
2088
                break;
2089
            else
2090
                continue;
2091
        }
2092

    
2093
        if (do_pkt_dump) {
2094
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2095
        }
2096
        /* the following test is needed in case new streams appear
2097
           dynamically in stream : we ignore them */
2098
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2099
            goto discard_packet;
2100
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2101
        ist = ist_table[ist_index];
2102
        if (ist->discard)
2103
            goto discard_packet;
2104

    
2105
        if (pkt.dts != AV_NOPTS_VALUE)
2106
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2107
        if (pkt.pts != AV_NOPTS_VALUE)
2108
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2109

    
2110
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2111
            if(pkt.pts != AV_NOPTS_VALUE)
2112
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2113
            if(pkt.dts != AV_NOPTS_VALUE)
2114
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2115
        }
2116

    
2117
//        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);
2118
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2119
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2120
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2121
            int64_t delta= pkt_dts - ist->next_pts;
2122
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2123
                input_files_ts_offset[ist->file_index]-= delta;
2124
                if (verbose > 2)
2125
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2126
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2127
                if(pkt.pts != AV_NOPTS_VALUE)
2128
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2129
            }
2130
        }
2131

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

    
2135
            if (verbose >= 0)
2136
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2137
                        ist->file_index, ist->index);
2138
            if (exit_on_error)
2139
                av_exit(1);
2140
            av_free_packet(&pkt);
2141
            goto redo;
2142
        }
2143

    
2144
    discard_packet:
2145
        av_free_packet(&pkt);
2146

    
2147
        /* dump report by using the output first video and audio streams */
2148
        print_report(output_files, ost_table, nb_ostreams, 0);
2149
    }
2150

    
2151
    /* at the end of stream, we must flush the decoder buffers */
2152
    for(i=0;i<nb_istreams;i++) {
2153
        ist = ist_table[i];
2154
        if (ist->decoding_needed) {
2155
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2156
        }
2157
    }
2158

    
2159
    term_exit();
2160

    
2161
    /* write the trailer if needed and close file */
2162
    for(i=0;i<nb_output_files;i++) {
2163
        os = output_files[i];
2164
        av_write_trailer(os);
2165
    }
2166

    
2167
    /* dump report by using the first video and audio streams */
2168
    print_report(output_files, ost_table, nb_ostreams, 1);
2169

    
2170
    /* close each encoder */
2171
    for(i=0;i<nb_ostreams;i++) {
2172
        ost = ost_table[i];
2173
        if (ost->encoding_needed) {
2174
            av_freep(&ost->st->codec->stats_in);
2175
            avcodec_close(ost->st->codec);
2176
        }
2177
    }
2178

    
2179
    /* close each decoder */
2180
    for(i=0;i<nb_istreams;i++) {
2181
        ist = ist_table[i];
2182
        if (ist->decoding_needed) {
2183
            avcodec_close(ist->st->codec);
2184
        }
2185
    }
2186

    
2187
    /* finished ! */
2188

    
2189
    ret = 0;
2190
 fail1:
2191
    av_freep(&bit_buffer);
2192
    av_free(file_table);
2193

    
2194
    if (ist_table) {
2195
        for(i=0;i<nb_istreams;i++) {
2196
            ist = ist_table[i];
2197
            av_free(ist);
2198
        }
2199
        av_free(ist_table);
2200
    }
2201
    if (ost_table) {
2202
        for(i=0;i<nb_ostreams;i++) {
2203
            ost = ost_table[i];
2204
            if (ost) {
2205
                if (ost->logfile) {
2206
                    fclose(ost->logfile);
2207
                    ost->logfile = NULL;
2208
                }
2209
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2210
                                             initialized but set to zero */
2211
                av_free(ost->pict_tmp.data[0]);
2212
                if (ost->video_resample)
2213
                    sws_freeContext(ost->img_resample_ctx);
2214
                if (ost->resample)
2215
                    audio_resample_close(ost->resample);
2216
                if (ost->reformat_ctx)
2217
                    av_audio_convert_free(ost->reformat_ctx);
2218
                av_free(ost);
2219
            }
2220
        }
2221
        av_free(ost_table);
2222
    }
2223
    return ret;
2224
 fail:
2225
    ret = AVERROR(ENOMEM);
2226
    goto fail1;
2227
}
2228

    
2229
#if 0
2230
int file_read(const char *filename)
2231
{
2232
    URLContext *h;
2233
    unsigned char buffer[1024];
2234
    int len, i;
2235

2236
    if (url_open(&h, filename, O_RDONLY) < 0) {
2237
        printf("could not open '%s'\n", filename);
2238
        return -1;
2239
    }
2240
    for(;;) {
2241
        len = url_read(h, buffer, sizeof(buffer));
2242
        if (len <= 0)
2243
            break;
2244
        for(i=0;i<len;i++) putchar(buffer[i]);
2245
    }
2246
    url_close(h);
2247
    return 0;
2248
}
2249
#endif
2250

    
2251
static void opt_format(const char *arg)
2252
{
2253
    /* compatibility stuff for pgmyuv */
2254
    if (!strcmp(arg, "pgmyuv")) {
2255
        pgmyuv_compatibility_hack=1;
2256
//        opt_image_format(arg);
2257
        arg = "image2";
2258
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2259
    }
2260

    
2261
    file_iformat = av_find_input_format(arg);
2262
    file_oformat = guess_format(arg, NULL, NULL);
2263
    if (!file_iformat && !file_oformat) {
2264
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2265
        av_exit(1);
2266
    }
2267
}
2268

    
2269
static void opt_video_rc_override_string(const char *arg)
2270
{
2271
    video_rc_override_string = arg;
2272
}
2273

    
2274
static int opt_me_threshold(const char *opt, const char *arg)
2275
{
2276
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2277
    return 0;
2278
}
2279

    
2280
static int opt_verbose(const char *opt, const char *arg)
2281
{
2282
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2283
    av_log_set_level(verbose);
2284
    return 0;
2285
}
2286

    
2287
static int opt_frame_rate(const char *opt, const char *arg)
2288
{
2289
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2290
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2291
        av_exit(1);
2292
    }
2293
    return 0;
2294
}
2295

    
2296
static int opt_bitrate(const char *opt, const char *arg)
2297
{
2298
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2299

    
2300
    opt_default(opt, arg);
2301

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

    
2305
    return 0;
2306
}
2307

    
2308
static void opt_frame_crop_top(const char *arg)
2309
{
2310
    frame_topBand = atoi(arg);
2311
    if (frame_topBand < 0) {
2312
        fprintf(stderr, "Incorrect top crop size\n");
2313
        av_exit(1);
2314
    }
2315
    if ((frame_topBand % 2) != 0) {
2316
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2317
        av_exit(1);
2318
    }
2319
    if ((frame_topBand) >= frame_height){
2320
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2321
        av_exit(1);
2322
    }
2323
    frame_height -= frame_topBand;
2324
}
2325

    
2326
static void opt_frame_crop_bottom(const char *arg)
2327
{
2328
    frame_bottomBand = atoi(arg);
2329
    if (frame_bottomBand < 0) {
2330
        fprintf(stderr, "Incorrect bottom crop size\n");
2331
        av_exit(1);
2332
    }
2333
    if ((frame_bottomBand % 2) != 0) {
2334
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2335
        av_exit(1);
2336
    }
2337
    if ((frame_bottomBand) >= frame_height){
2338
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2339
        av_exit(1);
2340
    }
2341
    frame_height -= frame_bottomBand;
2342
}
2343

    
2344
static void opt_frame_crop_left(const char *arg)
2345
{
2346
    frame_leftBand = atoi(arg);
2347
    if (frame_leftBand < 0) {
2348
        fprintf(stderr, "Incorrect left crop size\n");
2349
        av_exit(1);
2350
    }
2351
    if ((frame_leftBand % 2) != 0) {
2352
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2353
        av_exit(1);
2354
    }
2355
    if ((frame_leftBand) >= frame_width){
2356
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2357
        av_exit(1);
2358
    }
2359
    frame_width -= frame_leftBand;
2360
}
2361

    
2362
static void opt_frame_crop_right(const char *arg)
2363
{
2364
    frame_rightBand = atoi(arg);
2365
    if (frame_rightBand < 0) {
2366
        fprintf(stderr, "Incorrect right crop size\n");
2367
        av_exit(1);
2368
    }
2369
    if ((frame_rightBand % 2) != 0) {
2370
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2371
        av_exit(1);
2372
    }
2373
    if ((frame_rightBand) >= frame_width){
2374
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2375
        av_exit(1);
2376
    }
2377
    frame_width -= frame_rightBand;
2378
}
2379

    
2380
static void opt_frame_size(const char *arg)
2381
{
2382
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2383
        fprintf(stderr, "Incorrect frame size\n");
2384
        av_exit(1);
2385
    }
2386
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2387
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2388
        av_exit(1);
2389
    }
2390
}
2391

    
2392

    
2393
#define SCALEBITS 10
2394
#define ONE_HALF  (1 << (SCALEBITS - 1))
2395
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2396

    
2397
#define RGB_TO_Y(r, g, b) \
2398
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2399
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2400

    
2401
#define RGB_TO_U(r1, g1, b1, shift)\
2402
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2403
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2404

    
2405
#define RGB_TO_V(r1, g1, b1, shift)\
2406
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2407
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2408

    
2409
static void opt_pad_color(const char *arg) {
2410
    /* Input is expected to be six hex digits similar to
2411
       how colors are expressed in html tags (but without the #) */
2412
    int rgb = strtol(arg, NULL, 16);
2413
    int r,g,b;
2414

    
2415
    r = (rgb >> 16);
2416
    g = ((rgb >> 8) & 255);
2417
    b = (rgb & 255);
2418

    
2419
    padcolor[0] = RGB_TO_Y(r,g,b);
2420
    padcolor[1] = RGB_TO_U(r,g,b,0);
2421
    padcolor[2] = RGB_TO_V(r,g,b,0);
2422
}
2423

    
2424
static void opt_frame_pad_top(const char *arg)
2425
{
2426
    frame_padtop = atoi(arg);
2427
    if (frame_padtop < 0) {
2428
        fprintf(stderr, "Incorrect top pad size\n");
2429
        av_exit(1);
2430
    }
2431
    if ((frame_padtop % 2) != 0) {
2432
        fprintf(stderr, "Top pad size must be a multiple of 2\n");
2433
        av_exit(1);
2434
    }
2435
}
2436

    
2437
static void opt_frame_pad_bottom(const char *arg)
2438
{
2439
    frame_padbottom = atoi(arg);
2440
    if (frame_padbottom < 0) {
2441
        fprintf(stderr, "Incorrect bottom pad size\n");
2442
        av_exit(1);
2443
    }
2444
    if ((frame_padbottom % 2) != 0) {
2445
        fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2446
        av_exit(1);
2447
    }
2448
}
2449

    
2450

    
2451
static void opt_frame_pad_left(const char *arg)
2452
{
2453
    frame_padleft = atoi(arg);
2454
    if (frame_padleft < 0) {
2455
        fprintf(stderr, "Incorrect left pad size\n");
2456
        av_exit(1);
2457
    }
2458
    if ((frame_padleft % 2) != 0) {
2459
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2460
        av_exit(1);
2461
    }
2462
}
2463

    
2464

    
2465
static void opt_frame_pad_right(const char *arg)
2466
{
2467
    frame_padright = atoi(arg);
2468
    if (frame_padright < 0) {
2469
        fprintf(stderr, "Incorrect right pad size\n");
2470
        av_exit(1);
2471
    }
2472
    if ((frame_padright % 2) != 0) {
2473
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2474
        av_exit(1);
2475
    }
2476
}
2477

    
2478
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2479
{
2480
    int i;
2481
    char fmt_str[128];
2482
    for (i=-1; i < nb_fmts; i++) {
2483
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2484
        fprintf(stdout, "%s\n", fmt_str);
2485
    }
2486
}
2487

    
2488
static void opt_frame_pix_fmt(const char *arg)
2489
{
2490
    if (strcmp(arg, "list"))
2491
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2492
    else {
2493
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2494
        av_exit(0);
2495
    }
2496
}
2497

    
2498
static void opt_frame_aspect_ratio(const char *arg)
2499
{
2500
    int x = 0, y = 0;
2501
    double ar = 0;
2502
    const char *p;
2503
    char *end;
2504

    
2505
    p = strchr(arg, ':');
2506
    if (p) {
2507
        x = strtol(arg, &end, 10);
2508
        if (end == p)
2509
            y = strtol(end+1, &end, 10);
2510
        if (x > 0 && y > 0)
2511
            ar = (double)x / (double)y;
2512
    } else
2513
        ar = strtod(arg, NULL);
2514

    
2515
    if (!ar) {
2516
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2517
        av_exit(1);
2518
    }
2519
    frame_aspect_ratio = ar;
2520
}
2521

    
2522
static void opt_qscale(const char *arg)
2523
{
2524
    video_qscale = atof(arg);
2525
    if (video_qscale <= 0 ||
2526
        video_qscale > 255) {
2527
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2528
        av_exit(1);
2529
    }
2530
}
2531

    
2532
static void opt_top_field_first(const char *arg)
2533
{
2534
    top_field_first= atoi(arg);
2535
}
2536

    
2537
static int opt_thread_count(const char *opt, const char *arg)
2538
{
2539
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2540
#if !defined(HAVE_THREADS)
2541
    if (verbose >= 0)
2542
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2543
#endif
2544
    return 0;
2545
}
2546

    
2547
static void opt_audio_sample_fmt(const char *arg)
2548
{
2549
    if (strcmp(arg, "list"))
2550
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2551
    else {
2552
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2553
        av_exit(0);
2554
    }
2555
}
2556

    
2557
static int opt_audio_rate(const char *opt, const char *arg)
2558
{
2559
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2560
    return 0;
2561
}
2562

    
2563
static int opt_audio_channels(const char *opt, const char *arg)
2564
{
2565
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2566
    return 0;
2567
}
2568

    
2569
static void opt_video_channel(const char *arg)
2570
{
2571
    video_channel = strtol(arg, NULL, 0);
2572
}
2573

    
2574
static void opt_video_standard(const char *arg)
2575
{
2576
    video_standard = av_strdup(arg);
2577
}
2578

    
2579
static void opt_codec(int *pstream_copy, char **pcodec_name,
2580
                      int codec_type, const char *arg)
2581
{
2582
    av_freep(pcodec_name);
2583
    if (!strcmp(arg, "copy")) {
2584
        *pstream_copy = 1;
2585
    } else {
2586
        *pcodec_name = av_strdup(arg);
2587
    }
2588
}
2589

    
2590
static void opt_audio_codec(const char *arg)
2591
{
2592
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2593
}
2594

    
2595
static void opt_audio_tag(const char *arg)
2596
{
2597
    char *tail;
2598
    audio_codec_tag= strtol(arg, &tail, 0);
2599

    
2600
    if(!tail || *tail)
2601
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2602
}
2603

    
2604
static void opt_video_tag(const char *arg)
2605
{
2606
    char *tail;
2607
    video_codec_tag= strtol(arg, &tail, 0);
2608

    
2609
    if(!tail || *tail)
2610
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2611
}
2612

    
2613
#ifdef CONFIG_VHOOK
2614
static void add_frame_hooker(const char *arg)
2615
{
2616
    int argc = 0;
2617
    char *argv[64];
2618
    int i;
2619
    char *args = av_strdup(arg);
2620

    
2621
    using_vhook = 1;
2622

    
2623
    argv[0] = strtok(args, " ");
2624
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2625
    }
2626

    
2627
    i = frame_hook_add(argc, argv);
2628

    
2629
    if (i != 0) {
2630
        fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2631
        av_exit(1);
2632
    }
2633
}
2634
#endif
2635

    
2636
static void opt_video_codec(const char *arg)
2637
{
2638
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2639
}
2640

    
2641
static void opt_subtitle_codec(const char *arg)
2642
{
2643
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2644
}
2645

    
2646
static void opt_map(const char *arg)
2647
{
2648
    AVStreamMap *m;
2649
    char *p;
2650

    
2651
    m = &stream_maps[nb_stream_maps++];
2652

    
2653
    m->file_index = strtol(arg, &p, 0);
2654
    if (*p)
2655
        p++;
2656

    
2657
    m->stream_index = strtol(p, &p, 0);
2658
    if (*p) {
2659
        p++;
2660
        m->sync_file_index = strtol(p, &p, 0);
2661
        if (*p)
2662
            p++;
2663
        m->sync_stream_index = strtol(p, &p, 0);
2664
    } else {
2665
        m->sync_file_index = m->file_index;
2666
        m->sync_stream_index = m->stream_index;
2667
    }
2668
}
2669

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

    
2675
    m = &meta_data_maps[nb_meta_data_maps++];
2676

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

    
2681
    m->in_file = strtol(p, &p, 0);
2682
}
2683

    
2684
static void opt_input_ts_scale(const char *arg)
2685
{
2686
    unsigned int stream;
2687
    double scale;
2688
    char *p;
2689

    
2690
    stream = strtol(arg, &p, 0);
2691
    if (*p)
2692
        p++;
2693
    scale= strtod(p, &p);
2694

    
2695
    if(stream >= MAX_STREAMS)
2696
        av_exit(1);
2697

    
2698
    input_files_ts_scale[nb_input_files][stream]= scale;
2699
}
2700

    
2701
static int opt_recording_time(const char *opt, const char *arg)
2702
{
2703
    recording_time = parse_time_or_die(opt, arg, 1);
2704
    return 0;
2705
}
2706

    
2707
static int opt_start_time(const char *opt, const char *arg)
2708
{
2709
    start_time = parse_time_or_die(opt, arg, 1);
2710
    return 0;
2711
}
2712

    
2713
static int opt_rec_timestamp(const char *opt, const char *arg)
2714
{
2715
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2716
    return 0;
2717
}
2718

    
2719
static int opt_input_ts_offset(const char *opt, const char *arg)
2720
{
2721
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2722
    return 0;
2723
}
2724

    
2725
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2726
{
2727
    const char *codec_string = encoder ? "encoder" : "decoder";
2728
    AVCodec *codec;
2729

    
2730
    if(!name)
2731
        return CODEC_ID_NONE;
2732
    codec = encoder ?
2733
        avcodec_find_encoder_by_name(name) :
2734
        avcodec_find_decoder_by_name(name);
2735
    if(!codec) {
2736
        av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2737
        av_exit(1);
2738
    }
2739
    if(codec->type != type) {
2740
        av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2741
        av_exit(1);
2742
    }
2743
    return codec->id;
2744
}
2745

    
2746
static void opt_input_file(const char *filename)
2747
{
2748
    AVFormatContext *ic;
2749
    AVFormatParameters params, *ap = &params;
2750
    int err, i, ret, rfps, rfps_base;
2751
    int64_t timestamp;
2752

    
2753
    if (!strcmp(filename, "-"))
2754
        filename = "pipe:";
2755

    
2756
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2757
                    !strcmp(filename, "/dev/stdin");
2758

    
2759
    /* get default parameters from command line */
2760
    ic = av_alloc_format_context();
2761

    
2762
    memset(ap, 0, sizeof(*ap));
2763
    ap->prealloced_context = 1;
2764
    ap->sample_rate = audio_sample_rate;
2765
    ap->channels = audio_channels;
2766
    ap->time_base.den = frame_rate.num;
2767
    ap->time_base.num = frame_rate.den;
2768
    ap->width = frame_width + frame_padleft + frame_padright;
2769
    ap->height = frame_height + frame_padtop + frame_padbottom;
2770
    ap->pix_fmt = frame_pix_fmt;
2771
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2772
    ap->channel = video_channel;
2773
    ap->standard = video_standard;
2774
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2775
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2776
    if(pgmyuv_compatibility_hack)
2777
        ap->video_codec_id= CODEC_ID_PGMYUV;
2778

    
2779
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2780

    
2781
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2782
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2783
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2784

    
2785
    /* open the input file with generic libav function */
2786
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2787
    if (err < 0) {
2788
        print_error(filename, err);
2789
        av_exit(1);
2790
    }
2791
    if(opt_programid) {
2792
        int i;
2793
        for(i=0; i<ic->nb_programs; i++)
2794
            if(ic->programs[i]->id != opt_programid)
2795
                ic->programs[i]->discard = AVDISCARD_ALL;
2796
    }
2797

    
2798
    ic->loop_input = loop_input;
2799

    
2800
    /* If not enough info to get the stream parameters, we decode the
2801
       first frames to get it. (used in mpeg case for example) */
2802
    ret = av_find_stream_info(ic);
2803
    if (ret < 0 && verbose >= 0) {
2804
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2805
        av_exit(1);
2806
    }
2807

    
2808
    timestamp = start_time;
2809
    /* add the stream start time */
2810
    if (ic->start_time != AV_NOPTS_VALUE)
2811
        timestamp += ic->start_time;
2812

    
2813
    /* if seeking requested, we execute it */
2814
    if (start_time != 0) {
2815
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2816
        if (ret < 0) {
2817
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2818
                    filename, (double)timestamp / AV_TIME_BASE);
2819
        }
2820
        /* reset seek info */
2821
        start_time = 0;
2822
    }
2823

    
2824
    /* update the current parameters so that they match the one of the input stream */
2825
    for(i=0;i<ic->nb_streams;i++) {
2826
        AVCodecContext *enc = ic->streams[i]->codec;
2827
        if(thread_count>1)
2828
            avcodec_thread_init(enc, thread_count);
2829
        enc->thread_count= thread_count;
2830
        switch(enc->codec_type) {
2831
        case CODEC_TYPE_AUDIO:
2832
            set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2833
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2834
            channel_layout = enc->channel_layout;
2835
            audio_channels = enc->channels;
2836
            audio_sample_rate = enc->sample_rate;
2837
            audio_sample_fmt = enc->sample_fmt;
2838
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2839
            if(audio_disable)
2840
                ic->streams[i]->discard= AVDISCARD_ALL;
2841
            break;
2842
        case CODEC_TYPE_VIDEO:
2843
            set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2844
            frame_height = enc->height;
2845
            frame_width = enc->width;
2846
            if(ic->streams[i]->sample_aspect_ratio.num)
2847
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2848
            else
2849
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2850
            frame_aspect_ratio *= (float) enc->width / enc->height;
2851
            frame_pix_fmt = enc->pix_fmt;
2852
            rfps      = ic->streams[i]->r_frame_rate.num;
2853
            rfps_base = ic->streams[i]->r_frame_rate.den;
2854
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2855
            if(me_threshold)
2856
                enc->debug |= FF_DEBUG_MV;
2857

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

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

    
2864
                    (float)rfps / rfps_base, rfps, rfps_base);
2865
            }
2866
            /* update the current frame rate to match the stream frame rate */
2867
            frame_rate.num = rfps;
2868
            frame_rate.den = rfps_base;
2869

    
2870
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2871
            if(video_disable)
2872
                ic->streams[i]->discard= AVDISCARD_ALL;
2873
            else if(video_discard)
2874
                ic->streams[i]->discard= video_discard;
2875
            break;
2876
        case CODEC_TYPE_DATA:
2877
            break;
2878
        case CODEC_TYPE_SUBTITLE:
2879
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2880
            if(subtitle_disable)
2881
                ic->streams[i]->discard = AVDISCARD_ALL;
2882
            break;
2883
        case CODEC_TYPE_ATTACHMENT:
2884
        case CODEC_TYPE_UNKNOWN:
2885
            nb_icodecs++;
2886
            break;
2887
        default:
2888
            abort();
2889
        }
2890
    }
2891

    
2892
    input_files[nb_input_files] = ic;
2893
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2894
    /* dump the file content */
2895
    if (verbose >= 0)
2896
        dump_format(ic, nb_input_files, filename, 0);
2897

    
2898
    nb_input_files++;
2899
    file_iformat = NULL;
2900
    file_oformat = NULL;
2901

    
2902
    video_channel = 0;
2903

    
2904
    av_freep(&video_codec_name);
2905
    av_freep(&audio_codec_name);
2906
    av_freep(&subtitle_codec_name);
2907
}
2908

    
2909
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2910
                                         int *has_subtitle_ptr)
2911
{
2912
    int has_video, has_audio, has_subtitle, i, j;
2913
    AVFormatContext *ic;
2914

    
2915
    has_video = 0;
2916
    has_audio = 0;
2917
    has_subtitle = 0;
2918
    for(j=0;j<nb_input_files;j++) {
2919
        ic = input_files[j];
2920
        for(i=0;i<ic->nb_streams;i++) {
2921
            AVCodecContext *enc = ic->streams[i]->codec;
2922
            switch(enc->codec_type) {
2923
            case CODEC_TYPE_AUDIO:
2924
                has_audio = 1;
2925
                break;
2926
            case CODEC_TYPE_VIDEO:
2927
                has_video = 1;
2928
                break;
2929
            case CODEC_TYPE_SUBTITLE:
2930
                has_subtitle = 1;
2931
                break;
2932
            case CODEC_TYPE_DATA:
2933
            case CODEC_TYPE_ATTACHMENT:
2934
            case CODEC_TYPE_UNKNOWN:
2935
                break;
2936
            default:
2937
                abort();
2938
            }
2939
        }
2940
    }
2941
    *has_video_ptr = has_video;
2942
    *has_audio_ptr = has_audio;
2943
    *has_subtitle_ptr = has_subtitle;
2944
}
2945

    
2946
static void new_video_stream(AVFormatContext *oc)
2947
{
2948
    AVStream *st;
2949
    AVCodecContext *video_enc;
2950
    int codec_id;
2951

    
2952
    st = av_new_stream(oc, oc->nb_streams);
2953
    if (!st) {
2954
        fprintf(stderr, "Could not alloc stream\n");
2955
        av_exit(1);
2956
    }
2957
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2958
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2959
    video_bitstream_filters= NULL;
2960

    
2961
    if(thread_count>1)
2962
        avcodec_thread_init(st->codec, thread_count);
2963

    
2964
    video_enc = st->codec;
2965

    
2966
    if(video_codec_tag)
2967
        video_enc->codec_tag= video_codec_tag;
2968

    
2969
    if(   (video_global_header&1)
2970
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2971
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2972
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2973
    }
2974
    if(video_global_header&2){
2975
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2976
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2977
    }
2978

    
2979
    if (video_stream_copy) {
2980
        st->stream_copy = 1;
2981
        video_enc->codec_type = CODEC_TYPE_VIDEO;
2982
        video_enc->sample_aspect_ratio =
2983
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2984
    } else {
2985
        const char *p;
2986
        int i;
2987
        AVCodec *codec;
2988
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2989

    
2990
        if (video_codec_name) {
2991
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2992
            codec = avcodec_find_encoder_by_name(video_codec_name);
2993
            output_codecs[nb_ocodecs] = codec;
2994
        } else {
2995
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2996
            codec = avcodec_find_encoder(codec_id);
2997
        }
2998

    
2999
        video_enc->codec_id = codec_id;
3000

    
3001
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3002

    
3003
        if (codec && codec->supported_framerates && !force_fps)
3004
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3005
        video_enc->time_base.den = fps.num;
3006
        video_enc->time_base.num = fps.den;
3007

    
3008
        video_enc->width = frame_width + frame_padright + frame_padleft;
3009
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3010
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3011
        video_enc->pix_fmt = frame_pix_fmt;
3012
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3013

    
3014
        if(codec && codec->pix_fmts){
3015
            const enum PixelFormat *p= codec->pix_fmts;
3016
            for(; *p!=-1; p++){
3017
                if(*p == video_enc->pix_fmt)
3018
                    break;
3019
            }
3020
            if(*p == -1)
3021
                video_enc->pix_fmt = codec->pix_fmts[0];
3022
        }
3023

    
3024
        if (intra_only)
3025
            video_enc->gop_size = 0;
3026
        if (video_qscale || same_quality) {
3027
            video_enc->flags |= CODEC_FLAG_QSCALE;
3028
            video_enc->global_quality=
3029
                st->quality = FF_QP2LAMBDA * video_qscale;
3030
        }
3031

    
3032
        if(intra_matrix)
3033
            video_enc->intra_matrix = intra_matrix;
3034
        if(inter_matrix)
3035
            video_enc->inter_matrix = inter_matrix;
3036

    
3037
        video_enc->thread_count = thread_count;
3038
        p= video_rc_override_string;
3039
        for(i=0; p; i++){
3040
            int start, end, q;
3041
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3042
            if(e!=3){
3043
                fprintf(stderr, "error parsing rc_override\n");
3044
                av_exit(1);
3045
            }
3046
            video_enc->rc_override=
3047
                av_realloc(video_enc->rc_override,
3048
                           sizeof(RcOverride)*(i+1));
3049
            video_enc->rc_override[i].start_frame= start;
3050
            video_enc->rc_override[i].end_frame  = end;
3051
            if(q>0){
3052
                video_enc->rc_override[i].qscale= q;
3053
                video_enc->rc_override[i].quality_factor= 1.0;
3054
            }
3055
            else{
3056
                video_enc->rc_override[i].qscale= 0;
3057
                video_enc->rc_override[i].quality_factor= -q/100.0;
3058
            }
3059
            p= strchr(p, '/');
3060
            if(p) p++;
3061
        }
3062
        video_enc->rc_override_count=i;
3063
        if (!video_enc->rc_initial_buffer_occupancy)
3064
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3065
        video_enc->me_threshold= me_threshold;
3066
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3067

    
3068
        if (do_psnr)
3069
            video_enc->flags|= CODEC_FLAG_PSNR;
3070

    
3071
        /* two pass mode */
3072
        if (do_pass) {
3073
            if (do_pass == 1) {
3074
                video_enc->flags |= CODEC_FLAG_PASS1;
3075
            } else {
3076
                video_enc->flags |= CODEC_FLAG_PASS2;
3077
            }
3078
        }
3079
    }
3080
    nb_ocodecs++;
3081

    
3082
    /* reset some key parameters */
3083
    video_disable = 0;
3084
    av_freep(&video_codec_name);
3085
    video_stream_copy = 0;
3086
}
3087

    
3088
static void new_audio_stream(AVFormatContext *oc)
3089
{
3090
    AVStream *st;
3091
    AVCodecContext *audio_enc;
3092
    int codec_id;
3093

    
3094
    st = av_new_stream(oc, oc->nb_streams);
3095
    if (!st) {
3096
        fprintf(stderr, "Could not alloc stream\n");
3097
        av_exit(1);
3098
    }
3099
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3100

    
3101
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3102
    audio_bitstream_filters= NULL;
3103

    
3104
    if(thread_count>1)
3105
        avcodec_thread_init(st->codec, thread_count);
3106

    
3107
    audio_enc = st->codec;
3108
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3109

    
3110
    if(audio_codec_tag)
3111
        audio_enc->codec_tag= audio_codec_tag;
3112

    
3113
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3114
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3115
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3116
    }
3117
    if (audio_stream_copy) {
3118
        st->stream_copy = 1;
3119
        audio_enc->channels = audio_channels;
3120
    } else {
3121
        AVCodec *codec;
3122

    
3123
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3124

    
3125
        if (audio_codec_name) {
3126
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3127
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3128
            output_codecs[nb_ocodecs] = codec;
3129
        } else {
3130
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3131
            codec = avcodec_find_encoder(codec_id);
3132
        }
3133
        audio_enc->codec_id = codec_id;
3134

    
3135
        if (audio_qscale > QSCALE_NONE) {
3136
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3137
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3138
        }
3139
        audio_enc->thread_count = thread_count;
3140
        audio_enc->channels = audio_channels;
3141
        audio_enc->sample_fmt = audio_sample_fmt;
3142
        audio_enc->channel_layout = channel_layout;
3143

    
3144
        if(codec && codec->sample_fmts){
3145
            const enum SampleFormat *p= codec->sample_fmts;
3146
            for(; *p!=-1; p++){
3147
                if(*p == audio_enc->sample_fmt)
3148
                    break;
3149
            }
3150
            if(*p == -1)
3151
                audio_enc->sample_fmt = codec->sample_fmts[0];
3152
        }
3153
    }
3154
    nb_ocodecs++;
3155
    audio_enc->sample_rate = audio_sample_rate;
3156
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3157
    if (audio_language) {
3158
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3159
        av_free(audio_language);
3160
        audio_language = NULL;
3161
    }
3162

    
3163
    /* reset some key parameters */
3164
    audio_disable = 0;
3165
    av_freep(&audio_codec_name);
3166
    audio_stream_copy = 0;
3167
}
3168

    
3169
static void new_subtitle_stream(AVFormatContext *oc)
3170
{
3171
    AVStream *st;
3172
    AVCodecContext *subtitle_enc;
3173

    
3174
    st = av_new_stream(oc, oc->nb_streams);
3175
    if (!st) {
3176
        fprintf(stderr, "Could not alloc stream\n");
3177
        av_exit(1);
3178
    }
3179
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3180

    
3181
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3182
    subtitle_bitstream_filters= NULL;
3183

    
3184
    subtitle_enc = st->codec;
3185
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3186
    if (subtitle_stream_copy) {
3187
        st->stream_copy = 1;
3188
    } else {
3189
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3190
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3191
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3192
    }
3193
    nb_ocodecs++;
3194

    
3195
    if (subtitle_language) {
3196
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3197
        av_free(subtitle_language);
3198
        subtitle_language = NULL;
3199
    }
3200

    
3201
    subtitle_disable = 0;
3202
    av_freep(&subtitle_codec_name);
3203
    subtitle_stream_copy = 0;
3204
}
3205

    
3206
static void opt_new_audio_stream(void)
3207
{
3208
    AVFormatContext *oc;
3209
    if (nb_output_files <= 0) {
3210
        fprintf(stderr, "At least one output file must be specified\n");
3211
        av_exit(1);
3212
    }
3213
    oc = output_files[nb_output_files - 1];
3214
    new_audio_stream(oc);
3215
}
3216

    
3217
static void opt_new_video_stream(void)
3218
{
3219
    AVFormatContext *oc;
3220
    if (nb_output_files <= 0) {
3221
        fprintf(stderr, "At least one output file must be specified\n");
3222
        av_exit(1);
3223
    }
3224
    oc = output_files[nb_output_files - 1];
3225
    new_video_stream(oc);
3226
}
3227

    
3228
static void opt_new_subtitle_stream(void)
3229
{
3230
    AVFormatContext *oc;
3231
    if (nb_output_files <= 0) {
3232
        fprintf(stderr, "At least one output file must be specified\n");
3233
        av_exit(1);
3234
    }
3235
    oc = output_files[nb_output_files - 1];
3236
    new_subtitle_stream(oc);
3237
}
3238

    
3239
static void opt_output_file(const char *filename)
3240
{
3241
    AVFormatContext *oc;
3242
    int use_video, use_audio, use_subtitle;
3243
    int input_has_video, input_has_audio, input_has_subtitle;
3244
    AVFormatParameters params, *ap = &params;
3245

    
3246
    if (!strcmp(filename, "-"))
3247
        filename = "pipe:";
3248

    
3249
    oc = av_alloc_format_context();
3250

    
3251
    if (!file_oformat) {
3252
        file_oformat = guess_format(NULL, filename, NULL);
3253
        if (!file_oformat) {
3254
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3255
                    filename);
3256
            av_exit(1);
3257
        }
3258
    }
3259

    
3260
    oc->oformat = file_oformat;
3261
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3262

    
3263
    if (!strcmp(file_oformat->name, "ffm") &&
3264
        av_strstart(filename, "http:", NULL)) {
3265
        /* special case for files sent to ffserver: we get the stream
3266
           parameters from ffserver */
3267
        int err = read_ffserver_streams(oc, filename);
3268
        if (err < 0) {
3269
            print_error(filename, err);
3270
            av_exit(1);
3271
        }
3272
    } else {
3273
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3274
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3275
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3276

    
3277
        /* disable if no corresponding type found and at least one
3278
           input file */
3279
        if (nb_input_files > 0) {
3280
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3281
                                         &input_has_subtitle);
3282
            if (!input_has_video)
3283
                use_video = 0;
3284
            if (!input_has_audio)
3285
                use_audio = 0;
3286
            if (!input_has_subtitle)
3287
                use_subtitle = 0;
3288
        }
3289

    
3290
        /* manual disable */
3291
        if (audio_disable) {
3292
            use_audio = 0;
3293
        }
3294
        if (video_disable) {
3295
            use_video = 0;
3296
        }
3297
        if (subtitle_disable) {
3298
            use_subtitle = 0;
3299
        }
3300

    
3301
        if (use_video) {
3302
            new_video_stream(oc);
3303
        }
3304

    
3305
        if (use_audio) {
3306
            new_audio_stream(oc);
3307
        }
3308

    
3309
        if (use_subtitle) {
3310
            new_subtitle_stream(oc);
3311
        }
3312

    
3313
        oc->timestamp = rec_timestamp;
3314

    
3315
        if (str_title)
3316
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3317
        if (str_author)
3318
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3319
        if (str_copyright)
3320
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3321
        if (str_comment)
3322
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3323
        if (str_album)
3324
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3325
        if (str_genre)
3326
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3327
    }
3328

    
3329
    output_files[nb_output_files++] = oc;
3330

    
3331
    /* check filename in case of an image number is expected */
3332
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3333
        if (!av_filename_number_test(oc->filename)) {
3334
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3335
            av_exit(1);
3336
        }
3337
    }
3338

    
3339
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3340
        /* test if it already exists to avoid loosing precious files */
3341
        if (!file_overwrite &&
3342
            (strchr(filename, ':') == NULL ||
3343
             filename[1] == ':' ||
3344
             av_strstart(filename, "file:", NULL))) {
3345
            if (url_exist(filename)) {
3346
                int c;
3347

    
3348
                if (!using_stdin) {
3349
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3350
                    fflush(stderr);
3351
                    c = getchar();
3352
                    if (toupper(c) != 'Y') {
3353
                        fprintf(stderr, "Not overwriting - exiting\n");
3354
                        av_exit(1);
3355
                    }
3356
                }
3357
                else {
3358
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3359
                    av_exit(1);
3360
                }
3361
            }
3362
        }
3363

    
3364
        /* open the file */
3365
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3366
            fprintf(stderr, "Could not open '%s'\n", filename);
3367
            av_exit(1);
3368
        }
3369
    }
3370

    
3371
    memset(ap, 0, sizeof(*ap));
3372
    if (av_set_parameters(oc, ap) < 0) {
3373
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3374
                oc->filename);
3375
        av_exit(1);
3376
    }
3377

    
3378
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3379
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3380
    oc->loop_output = loop_output;
3381

    
3382
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3383

    
3384
    /* reset some options */
3385
    file_oformat = NULL;
3386
    file_iformat = NULL;
3387
}
3388

    
3389
/* same option as mencoder */
3390
static void opt_pass(const char *pass_str)
3391
{
3392
    int pass;
3393
    pass = atoi(pass_str);
3394
    if (pass != 1 && pass != 2) {
3395
        fprintf(stderr, "pass number can be only 1 or 2\n");
3396
        av_exit(1);
3397
    }
3398
    do_pass = pass;
3399
}
3400

    
3401
static int64_t getutime(void)
3402
{
3403
#ifdef HAVE_GETRUSAGE
3404
    struct rusage rusage;
3405

    
3406
    getrusage(RUSAGE_SELF, &rusage);
3407
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3408
#elif defined(HAVE_GETPROCESSTIMES)
3409
    HANDLE proc;
3410
    FILETIME c, e, k, u;
3411
    proc = GetCurrentProcess();
3412
    GetProcessTimes(proc, &c, &e, &k, &u);
3413
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3414
#else
3415
    return av_gettime();
3416
#endif
3417
}
3418

    
3419
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3420
{
3421
    int i;
3422
    const char *p = str;
3423
    for(i = 0;; i++) {
3424
        dest[i] = atoi(p);
3425
        if(i == 63)
3426
            break;
3427
        p = strchr(p, ',');
3428
        if(!p) {
3429
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3430
            av_exit(1);
3431
        }
3432
        p++;
3433
    }
3434
}
3435

    
3436
static void opt_inter_matrix(const char *arg)
3437
{
3438
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3439
    parse_matrix_coeffs(inter_matrix, arg);
3440
}
3441

    
3442
static void opt_intra_matrix(const char *arg)
3443
{
3444
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3445
    parse_matrix_coeffs(intra_matrix, arg);
3446
}
3447

    
3448
/**
3449
 * Trivial log callback.
3450
 * Only suitable for show_help and similar since it lacks prefix handling.
3451
 */
3452
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3453
{
3454
    vfprintf(stdout, fmt, vl);
3455
}
3456

    
3457
static void show_help(void)
3458
{
3459
    av_log_set_callback(log_callback_help);
3460
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3461
           "Hyper fast Audio and Video encoder\n");
3462
    printf("\n");
3463
    show_help_options(options, "Main options:\n",
3464
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3465
    show_help_options(options, "\nAdvanced options:\n",
3466
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3467
                      OPT_EXPERT);
3468
    show_help_options(options, "\nVideo options:\n",
3469
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3470
                      OPT_VIDEO);
3471
    show_help_options(options, "\nAdvanced Video options:\n",
3472
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3473
                      OPT_VIDEO | OPT_EXPERT);
3474
    show_help_options(options, "\nAudio options:\n",
3475
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3476
                      OPT_AUDIO);
3477
    show_help_options(options, "\nAdvanced Audio options:\n",
3478
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3479
                      OPT_AUDIO | OPT_EXPERT);
3480
    show_help_options(options, "\nSubtitle options:\n",
3481
                      OPT_SUBTITLE | OPT_GRAB,
3482
                      OPT_SUBTITLE);
3483
    show_help_options(options, "\nAudio/Video grab options:\n",
3484
                      OPT_GRAB,
3485
                      OPT_GRAB);
3486
    printf("\n");
3487
    av_opt_show(avctx_opts[0], NULL);
3488
    printf("\n");
3489
    av_opt_show(avformat_opts, NULL);
3490
    printf("\n");
3491
    av_opt_show(sws_opts, NULL);
3492
}
3493

    
3494
static void opt_target(const char *arg)
3495
{
3496
    int norm = -1;
3497
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3498

    
3499
    if(!strncmp(arg, "pal-", 4)) {
3500
        norm = 0;
3501
        arg += 4;
3502
    } else if(!strncmp(arg, "ntsc-", 5)) {
3503
        norm = 1;
3504
        arg += 5;
3505
    } else if(!strncmp(arg, "film-", 5)) {
3506
        norm = 2;
3507
        arg += 5;
3508
    } else {
3509
        int fr;
3510
        /* Calculate FR via float to avoid int overflow */
3511
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3512
        if(fr == 25000) {
3513
            norm = 0;
3514
        } else if((fr == 29970) || (fr == 23976)) {
3515
            norm = 1;
3516
        } else {
3517
            /* Try to determine PAL/NTSC by peeking in the input files */
3518
            if(nb_input_files) {
3519
                int i, j;
3520
                for(j = 0; j < nb_input_files; j++) {
3521
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3522
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3523
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3524
                            continue;
3525
                        fr = c->time_base.den * 1000 / c->time_base.num;
3526
                        if(fr == 25000) {
3527
                            norm = 0;
3528
                            break;
3529
                        } else if((fr == 29970) || (fr == 23976)) {
3530
                            norm = 1;
3531
                            break;
3532
                        }
3533
                    }
3534
                    if(norm >= 0)
3535
                        break;
3536
                }
3537
            }
3538
        }
3539
        if(verbose && norm >= 0)
3540
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3541
    }
3542

    
3543
    if(norm < 0) {
3544
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3545
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3546
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3547
        av_exit(1);
3548
    }
3549

    
3550
    if(!strcmp(arg, "vcd")) {
3551

    
3552
        opt_video_codec("mpeg1video");
3553
        opt_audio_codec("mp2");
3554
        opt_format("vcd");
3555

    
3556
        opt_frame_size(norm ? "352x240" : "352x288");
3557
        opt_frame_rate(NULL, frame_rates[norm]);
3558
        opt_default("gop", norm ? "18" : "15");
3559

    
3560
        opt_default("b", "1150000");
3561
        opt_default("maxrate", "1150000");
3562
        opt_default("minrate", "1150000");
3563
        opt_default("bufsize", "327680"); // 40*1024*8;
3564

    
3565
        opt_default("ab", "224000");
3566
        audio_sample_rate = 44100;
3567
        audio_channels = 2;
3568

    
3569
        opt_default("packetsize", "2324");
3570
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3571

    
3572
        /* We have to offset the PTS, so that it is consistent with the SCR.
3573
           SCR starts at 36000, but the first two packs contain only padding
3574
           and the first pack from the other stream, respectively, may also have
3575
           been written before.
3576
           So the real data starts at SCR 36000+3*1200. */
3577
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3578
    } else if(!strcmp(arg, "svcd")) {
3579

    
3580
        opt_video_codec("mpeg2video");
3581
        opt_audio_codec("mp2");
3582
        opt_format("svcd");
3583

    
3584
        opt_frame_size(norm ? "480x480" : "480x576");
3585
        opt_frame_rate(NULL, frame_rates[norm]);
3586
        opt_default("gop", norm ? "18" : "15");
3587

    
3588
        opt_default("b", "2040000");
3589
        opt_default("maxrate", "2516000");
3590
        opt_default("minrate", "0"); //1145000;
3591
        opt_default("bufsize", "1835008"); //224*1024*8;
3592
        opt_default("flags", "+scan_offset");
3593

    
3594

    
3595
        opt_default("ab", "224000");
3596
        audio_sample_rate = 44100;
3597

    
3598
        opt_default("packetsize", "2324");
3599

    
3600
    } else if(!strcmp(arg, "dvd")) {
3601

    
3602
        opt_video_codec("mpeg2video");
3603
        opt_audio_codec("ac3");
3604
        opt_format("dvd");
3605

    
3606
        opt_frame_size(norm ? "720x480" : "720x576");
3607
        opt_frame_rate(NULL, frame_rates[norm]);
3608
        opt_default("gop", norm ? "18" : "15");
3609

    
3610
        opt_default("b", "6000000");
3611
        opt_default("maxrate", "9000000");
3612
        opt_default("minrate", "0"); //1500000;
3613
        opt_default("bufsize", "1835008"); //224*1024*8;
3614

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

    
3618
        opt_default("ab", "448000");
3619
        audio_sample_rate = 48000;
3620

    
3621
    } else if(!strncmp(arg, "dv", 2)) {
3622

    
3623
        opt_format("dv");
3624

    
3625
        opt_frame_size(norm ? "720x480" : "720x576");
3626
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3627
                                             (norm ? "yuv411p" : "yuv420p"));
3628
        opt_frame_rate(NULL, frame_rates[norm]);
3629

    
3630
        audio_sample_rate = 48000;
3631
        audio_channels = 2;
3632

    
3633
    } else {
3634
        fprintf(stderr, "Unknown target: %s\n", arg);
3635
        av_exit(1);
3636
    }
3637
}
3638

    
3639
static void opt_vstats_file (const char *arg)
3640
{
3641
    av_free (vstats_filename);
3642
    vstats_filename=av_strdup (arg);
3643
}
3644

    
3645
static void opt_vstats (void)
3646
{
3647
    char filename[40];
3648
    time_t today2 = time(NULL);
3649
    struct tm *today = localtime(&today2);
3650

    
3651
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3652
             today->tm_sec);
3653
    opt_vstats_file(filename);
3654
}
3655

    
3656
static int opt_bsf(const char *opt, const char *arg)
3657
{
3658
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3659
    AVBitStreamFilterContext **bsfp;
3660

    
3661
    if(!bsfc){
3662
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3663
        av_exit(1);
3664
    }
3665

    
3666
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3667
          *opt == 'a' ? &audio_bitstream_filters :
3668
                        &subtitle_bitstream_filters;
3669
    while(*bsfp)
3670
        bsfp= &(*bsfp)->next;
3671

    
3672
    *bsfp= bsfc;
3673

    
3674
    return 0;
3675
}
3676

    
3677
static int opt_preset(const char *opt, const char *arg)
3678
{
3679
    FILE *f=NULL;
3680
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3681
    int i;
3682
    const char *base[3]= { getenv("HOME"),
3683
                           "/usr/local/share",
3684
                           "/usr/share",
3685
                         };
3686

    
3687
    for(i=!base[0]; i<3 && !f; i++){
3688
        snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3689
        f= fopen(filename, "r");
3690
        if(!f){
3691
            char *codec_name= *opt == 'v' ? video_codec_name :
3692
                              *opt == 'a' ? audio_codec_name :
3693
                                            subtitle_codec_name;
3694
            snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s-%s.ffpreset", base[i],  i ? "" : ".", codec_name, arg);
3695
            f= fopen(filename, "r");
3696
        }
3697
    }
3698
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3699
              is_dos_path(arg))){
3700
        snprintf(filename, sizeof(filename), arg);
3701
        f= fopen(filename, "r");
3702
    }
3703

    
3704
    if(!f){
3705
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3706
        av_exit(1);
3707
    }
3708

    
3709
    while(!feof(f)){
3710
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3711
        if(line[0] == '#' && !e)
3712
            continue;
3713
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3714
        if(e){
3715
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3716
            av_exit(1);
3717
        }
3718
        if(!strcmp(tmp, "acodec")){
3719
            opt_audio_codec(tmp2);
3720
        }else if(!strcmp(tmp, "vcodec")){
3721
            opt_video_codec(tmp2);
3722
        }else if(!strcmp(tmp, "scodec")){
3723
            opt_subtitle_codec(tmp2);
3724
        }else if(opt_default(tmp, tmp2) < 0){
3725
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3726
            av_exit(1);
3727
        }
3728
    }
3729

    
3730
    fclose(f);
3731

    
3732
    return 0;
3733
}
3734

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

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

    
3827
    /* audio options */
3828
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3829
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3830
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3831
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3832
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3833
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3834
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3835
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3836
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3837
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3838
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3839
    { "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" },
3840

    
3841
    /* subtitle options */
3842
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3843
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3844
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3845
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3846

    
3847
    /* grab options */
3848
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3849
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3850
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3851

    
3852
    /* muxer options */
3853
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3854
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3855

    
3856
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3857
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3858
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3859

    
3860
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3861
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3862
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3863

    
3864
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3865
    { NULL, },
3866
};
3867

    
3868
int main(int argc, char **argv)
3869
{
3870
    int i;
3871
    int64_t ti;
3872

    
3873
    avcodec_register_all();
3874
    avdevice_register_all();
3875
    av_register_all();
3876

    
3877
    if(isatty(STDIN_FILENO))
3878
        url_set_interrupt_cb(decode_interrupt_cb);
3879

    
3880
    for(i=0; i<CODEC_TYPE_NB; i++){
3881
        avctx_opts[i]= avcodec_alloc_context2(i);
3882
    }
3883
    avformat_opts = av_alloc_format_context();
3884
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3885

    
3886
    show_banner();
3887

    
3888
    /* parse options */
3889
    parse_options(argc, argv, options, opt_output_file);
3890

    
3891
    /* file converter / grab */
3892
    if (nb_output_files <= 0) {
3893
        fprintf(stderr, "At least one output file must be specified\n");
3894
        av_exit(1);
3895
    }
3896

    
3897
    if (nb_input_files == 0) {
3898
        fprintf(stderr, "At least one input file must be specified\n");
3899
        av_exit(1);
3900
    }
3901

    
3902
    ti = getutime();
3903
    av_encode(output_files, nb_output_files, input_files, nb_input_files,
3904
              stream_maps, nb_stream_maps);
3905
    ti = getutime() - ti;
3906
    if (do_benchmark) {
3907
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3908
    }
3909

    
3910
    return av_exit(0);
3911
}