Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 8e2fd8e1

History | View | Annotate | Download (139 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
#if HAVE_SYS_RESOURCE_H
45
#include <sys/types.h>
46
#include <sys/resource.h>
47
#elif HAVE_GETPROCESSTIMES
48
#include <windows.h>
49
#endif
50

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

    
55
#if HAVE_TERMIOS_H
56
#include <fcntl.h>
57
#include <sys/ioctl.h>
58
#include <sys/time.h>
59
#include <termios.h>
60
#elif 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
#if 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
#if 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
#if 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
#if 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 HAVE_TERMIOS_H
356
    int n = 1;
357
    unsigned char ch;
358
#if !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 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
#if 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
            if (ret < 0) {
688
                fprintf(stderr, "Audio encoding failed\n");
689
                av_exit(1);
690
            }
691
            audio_size += ret;
692
            pkt.stream_index= ost->index;
693
            pkt.data= audio_out;
694
            pkt.size= ret;
695
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
696
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
697
            pkt.flags |= PKT_FLAG_KEY;
698
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
699

    
700
            ost->sync_opts += enc->frame_size;
701
        }
702
    } else {
703
        AVPacket pkt;
704
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
705
        av_init_packet(&pkt);
706

    
707
        ost->sync_opts += size_out / (osize * enc->channels);
708

    
709
        /* output a pcm frame */
710
        /* determine the size of the coded buffer */
711
        size_out /= osize;
712
        if (coded_bps)
713
            size_out *= coded_bps;
714

    
715
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
716
        ret = avcodec_encode_audio(enc, audio_out, size_out,
717
                                   (short *)buftmp);
718
        if (ret < 0) {
719
            fprintf(stderr, "Audio encoding failed\n");
720
            av_exit(1);
721
        }
722
        audio_size += ret;
723
        pkt.stream_index= ost->index;
724
        pkt.data= audio_out;
725
        pkt.size= ret;
726
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
727
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
728
        pkt.flags |= PKT_FLAG_KEY;
729
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
730
    }
731
}
732

    
733
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
734
{
735
    AVCodecContext *dec;
736
    AVPicture *picture2;
737
    AVPicture picture_tmp;
738
    uint8_t *buf = 0;
739

    
740
    dec = ist->st->codec;
741

    
742
    /* deinterlace : must be done before any resize */
743
    if (do_deinterlace || using_vhook) {
744
        int size;
745

    
746
        /* create temporary picture */
747
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
748
        buf = av_malloc(size);
749
        if (!buf)
750
            return;
751

    
752
        picture2 = &picture_tmp;
753
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
754

    
755
        if (do_deinterlace){
756
            if(avpicture_deinterlace(picture2, picture,
757
                                     dec->pix_fmt, dec->width, dec->height) < 0) {
758
                /* if error, do not deinterlace */
759
                fprintf(stderr, "Deinterlacing failed\n");
760
                av_free(buf);
761
                buf = NULL;
762
                picture2 = picture;
763
            }
764
        } else {
765
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
766
        }
767
    } else {
768
        picture2 = picture;
769
    }
770

    
771
    if (CONFIG_VHOOK)
772
        frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
773
                           1000000 * ist->pts / AV_TIME_BASE);
774

    
775
    if (picture != picture2)
776
        *picture = *picture2;
777
    *bufp = buf;
778
}
779

    
780
/* we begin to correct av delay at this threshold */
781
#define AV_DELAY_MAX 0.100
782

    
783
static void do_subtitle_out(AVFormatContext *s,
784
                            AVOutputStream *ost,
785
                            AVInputStream *ist,
786
                            AVSubtitle *sub,
787
                            int64_t pts)
788
{
789
    static uint8_t *subtitle_out = NULL;
790
    int subtitle_out_max_size = 65536;
791
    int subtitle_out_size, nb, i;
792
    AVCodecContext *enc;
793
    AVPacket pkt;
794

    
795
    if (pts == AV_NOPTS_VALUE) {
796
        fprintf(stderr, "Subtitle packets must have a pts\n");
797
        if (exit_on_error)
798
            av_exit(1);
799
        return;
800
    }
801

    
802
    enc = ost->st->codec;
803

    
804
    if (!subtitle_out) {
805
        subtitle_out = av_malloc(subtitle_out_max_size);
806
    }
807

    
808
    /* Note: DVB subtitle need one packet to draw them and one other
809
       packet to clear them */
810
    /* XXX: signal it in the codec context ? */
811
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
812
        nb = 2;
813
    else
814
        nb = 1;
815

    
816
    for(i = 0; i < nb; i++) {
817
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
818
                                                    subtitle_out_max_size, sub);
819

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

    
837
static int bit_buffer_size= 1024*256;
838
static uint8_t *bit_buffer= NULL;
839

    
840
static void do_video_out(AVFormatContext *s,
841
                         AVOutputStream *ost,
842
                         AVInputStream *ist,
843
                         AVFrame *in_picture,
844
                         int *frame_size)
845
{
846
    int nb_frames, i, ret;
847
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
848
    AVFrame picture_crop_temp, picture_pad_temp;
849
    AVCodecContext *enc, *dec;
850

    
851
    avcodec_get_frame_defaults(&picture_crop_temp);
852
    avcodec_get_frame_defaults(&picture_pad_temp);
853

    
854
    enc = ost->st->codec;
855
    dec = ist->st->codec;
856

    
857
    /* by default, we output a single frame */
858
    nb_frames = 1;
859

    
860
    *frame_size = 0;
861

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

    
885
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
886
    if (nb_frames <= 0)
887
        return;
888

    
889
    if (ost->video_crop) {
890
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
891
            av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
892
            if (exit_on_error)
893
                av_exit(1);
894
            return;
895
        }
896
        formatted_picture = &picture_crop_temp;
897
    } else {
898
        formatted_picture = in_picture;
899
    }
900

    
901
    final_picture = formatted_picture;
902
    padding_src = formatted_picture;
903
    resampling_dst = &ost->pict_tmp;
904
    if (ost->video_pad) {
905
        final_picture = &ost->pict_tmp;
906
        if (ost->video_resample) {
907
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
908
                av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
909
                if (exit_on_error)
910
                    av_exit(1);
911
                return;
912
            }
913
            resampling_dst = &picture_pad_temp;
914
        }
915
    }
916

    
917
    if (ost->video_resample) {
918
        padding_src = NULL;
919
        final_picture = &ost->pict_tmp;
920
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
921
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
922
    }
923

    
924
    if (ost->video_pad) {
925
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
926
                enc->height, enc->width, enc->pix_fmt,
927
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
928
    }
929

    
930
    /* duplicates frame if needed */
931
    for(i=0;i<nb_frames;i++) {
932
        AVPacket pkt;
933
        av_init_packet(&pkt);
934
        pkt.stream_index= ost->index;
935

    
936
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
937
            /* raw pictures are written as AVPicture structure to
938
               avoid any copies. We support temorarily the older
939
               method. */
940
            AVFrame* old_frame = enc->coded_frame;
941
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
942
            pkt.data= (uint8_t *)final_picture;
943
            pkt.size=  sizeof(AVPicture);
944
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
945
            pkt.flags |= PKT_FLAG_KEY;
946

    
947
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
948
            enc->coded_frame = old_frame;
949
        } else {
950
            AVFrame big_picture;
951

    
952
            big_picture= *final_picture;
953
            /* better than nothing: use input picture interlaced
954
               settings */
955
            big_picture.interlaced_frame = in_picture->interlaced_frame;
956
            if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
957
                if(top_field_first == -1)
958
                    big_picture.top_field_first = in_picture->top_field_first;
959
                else
960
                    big_picture.top_field_first = top_field_first;
961
            }
962

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

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

    
1011
static double psnr(double d){
1012
    return -10.0*log(d)/log(10.0);
1013
}
1014

    
1015
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1016
                           int frame_size)
1017
{
1018
    AVCodecContext *enc;
1019
    int frame_number;
1020
    double ti1, bitrate, avg_bitrate;
1021

    
1022
    /* this is executed just the first time do_video_stats is called */
1023
    if (!vstats_file) {
1024
        vstats_file = fopen(vstats_filename, "w");
1025
        if (!vstats_file) {
1026
            perror("fopen");
1027
            av_exit(1);
1028
        }
1029
    }
1030

    
1031
    enc = ost->st->codec;
1032
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1033
        frame_number = ost->frame_number;
1034
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1035
        if (enc->flags&CODEC_FLAG_PSNR)
1036
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1037

    
1038
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1039
        /* compute pts value */
1040
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1041
        if (ti1 < 0.01)
1042
            ti1 = 0.01;
1043

    
1044
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1045
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1046
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1047
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1048
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1049
    }
1050
}
1051

    
1052
static void print_report(AVFormatContext **output_files,
1053
                         AVOutputStream **ost_table, int nb_ostreams,
1054
                         int is_last_report)
1055
{
1056
    char buf[1024];
1057
    AVOutputStream *ost;
1058
    AVFormatContext *oc, *os;
1059
    int64_t total_size;
1060
    AVCodecContext *enc;
1061
    int frame_number, vid, i;
1062
    double bitrate, ti1, pts;
1063
    static int64_t last_time = -1;
1064
    static int qp_histogram[52];
1065

    
1066
    if (!is_last_report) {
1067
        int64_t cur_time;
1068
        /* display the report every 0.5 seconds */
1069
        cur_time = av_gettime();
1070
        if (last_time == -1) {
1071
            last_time = cur_time;
1072
            return;
1073
        }
1074
        if ((cur_time - last_time) < 500000)
1075
            return;
1076
        last_time = cur_time;
1077
    }
1078

    
1079

    
1080
    oc = output_files[0];
1081

    
1082
    total_size = url_fsize(oc->pb);
1083
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1084
        total_size= url_ftell(oc->pb);
1085

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

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

    
1147
    if (verbose || is_last_report) {
1148
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1149

    
1150
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1151
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1152
            (double)total_size / 1024, ti1, bitrate);
1153

    
1154
        if (verbose > 1)
1155
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1156
                  nb_frames_dup, nb_frames_drop);
1157

    
1158
        if (verbose >= 0)
1159
            fprintf(stderr, "%s    \r", buf);
1160

    
1161
        fflush(stderr);
1162
    }
1163

    
1164
    if (is_last_report && verbose >= 0){
1165
        int64_t raw= audio_size + video_size + extra_size;
1166
        fprintf(stderr, "\n");
1167
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1168
                video_size/1024.0,
1169
                audio_size/1024.0,
1170
                extra_size/1024.0,
1171
                100.0*(total_size - raw)/raw
1172
        );
1173
    }
1174
}
1175

    
1176
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1177
static int output_packet(AVInputStream *ist, int ist_index,
1178
                         AVOutputStream **ost_table, int nb_ostreams,
1179
                         const AVPacket *pkt)
1180
{
1181
    AVFormatContext *os;
1182
    AVOutputStream *ost;
1183
    uint8_t *ptr;
1184
    int len, ret, i;
1185
    uint8_t *data_buf;
1186
    int data_size, got_picture;
1187
    AVFrame picture;
1188
    void *buffer_to_free;
1189
    static unsigned int samples_size= 0;
1190
    static short *samples= NULL;
1191
    AVSubtitle subtitle, *subtitle_to_free;
1192
    int got_subtitle;
1193

    
1194
    if(ist->next_pts == AV_NOPTS_VALUE)
1195
        ist->next_pts= ist->pts;
1196

    
1197
    if (pkt == NULL) {
1198
        /* EOF handling */
1199
        ptr = NULL;
1200
        len = 0;
1201
        goto handle_eof;
1202
    }
1203

    
1204
    if(pkt->dts != AV_NOPTS_VALUE)
1205
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1206

    
1207
    len = pkt->size;
1208
    ptr = pkt->data;
1209

    
1210
    //while we have more to decode or while the decoder did output something on EOF
1211
    while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1212
    handle_eof:
1213
        ist->pts= ist->next_pts;
1214

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

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

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

    
1304
        buffer_to_free = NULL;
1305
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1306
            pre_process_video_frame(ist, (AVPicture *)&picture,
1307
                                    &buffer_to_free);
1308
        }
1309

    
1310
        // preprocess audio (volume)
1311
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1312
            if (audio_volume != 256) {
1313
                short *volp;
1314
                volp = samples;
1315
                for(i=0;i<(data_size / sizeof(short));i++) {
1316
                    int v = ((*volp) * audio_volume + 128) >> 8;
1317
                    if (v < -32768) v = -32768;
1318
                    if (v >  32767) v = 32767;
1319
                    *volp++ = v;
1320
                }
1321
            }
1322
        }
1323

    
1324
        /* frame rate emulation */
1325
        if (rate_emu) {
1326
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1327
            int64_t now = av_gettime() - ist->start;
1328
            if (pts > now)
1329
                usleep(pts - now);
1330
        }
1331

    
1332
        /* if output time reached then transcode raw format,
1333
           encode packets and output them */
1334
        if (start_time == 0 || ist->pts >= start_time)
1335
            for(i=0;i<nb_ostreams;i++) {
1336
                int frame_size;
1337

    
1338
                ost = ost_table[i];
1339
                if (ost->source_index == ist_index) {
1340
                    os = output_files[ost->file_index];
1341

    
1342
#if 0
1343
                    printf("%d: got pts=%0.3f %0.3f\n", i,
1344
                           (double)pkt->pts / AV_TIME_BASE,
1345
                           ((double)ist->pts / AV_TIME_BASE) -
1346
                           ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1347
#endif
1348
                    /* set the input output pts pairs */
1349
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1350

    
1351
                    if (ost->encoding_needed) {
1352
                        switch(ost->st->codec->codec_type) {
1353
                        case CODEC_TYPE_AUDIO:
1354
                            do_audio_out(os, ost, ist, data_buf, data_size);
1355
                            break;
1356
                        case CODEC_TYPE_VIDEO:
1357
                            do_video_out(os, ost, ist, &picture, &frame_size);
1358
                            if (vstats_filename && frame_size)
1359
                                do_video_stats(os, ost, frame_size);
1360
                            break;
1361
                        case CODEC_TYPE_SUBTITLE:
1362
                            do_subtitle_out(os, ost, ist, &subtitle,
1363
                                            pkt->pts);
1364
                            break;
1365
                        default:
1366
                            abort();
1367
                        }
1368
                    } else {
1369
                        AVFrame avframe; //FIXME/XXX remove this
1370
                        AVPacket opkt;
1371
                        av_init_packet(&opkt);
1372

    
1373
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1374
                            continue;
1375

    
1376
                        /* no reencoding needed : output the packet directly */
1377
                        /* force the input stream PTS */
1378

    
1379
                        avcodec_get_frame_defaults(&avframe);
1380
                        ost->st->codec->coded_frame= &avframe;
1381
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1382

    
1383
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1384
                            audio_size += data_size;
1385
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1386
                            video_size += data_size;
1387
                            ost->sync_opts++;
1388
                        }
1389

    
1390
                        opkt.stream_index= ost->index;
1391
                        if(pkt->pts != AV_NOPTS_VALUE)
1392
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1393
                        else
1394
                            opkt.pts= AV_NOPTS_VALUE;
1395

    
1396
                        if (pkt->dts == AV_NOPTS_VALUE)
1397
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1398
                        else
1399
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1400

    
1401
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1402
                        opkt.flags= pkt->flags;
1403

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

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

    
1434
        for(i=0;i<nb_ostreams;i++) {
1435
            ost = ost_table[i];
1436
            if (ost->source_index == ist_index) {
1437
                AVCodecContext *enc= ost->st->codec;
1438
                os = output_files[ost->file_index];
1439

    
1440
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1441
                    continue;
1442
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1443
                    continue;
1444

    
1445
                if (ost->encoding_needed) {
1446
                    for(;;) {
1447
                        AVPacket pkt;
1448
                        int fifo_bytes;
1449
                        av_init_packet(&pkt);
1450
                        pkt.stream_index= ost->index;
1451

    
1452
                        switch(ost->st->codec->codec_type) {
1453
                        case CODEC_TYPE_AUDIO:
1454
                            fifo_bytes = av_fifo_size(&ost->fifo);
1455
                            ret = 0;
1456
                            /* encode any samples remaining in fifo */
1457
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1458
                                int fs_tmp = enc->frame_size;
1459
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1460
                                av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1461
                                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1462
                                enc->frame_size = fs_tmp;
1463
                            }
1464
                            if(ret <= 0) {
1465
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1466
                            }
1467
                            if (ret < 0) {
1468
                                fprintf(stderr, "Audio encoding failed\n");
1469
                                av_exit(1);
1470
                            }
1471
                            audio_size += ret;
1472
                            pkt.flags |= PKT_FLAG_KEY;
1473
                            break;
1474
                        case CODEC_TYPE_VIDEO:
1475
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1476
                            if (ret < 0) {
1477
                                fprintf(stderr, "Video encoding failed\n");
1478
                                av_exit(1);
1479
                            }
1480
                            video_size += ret;
1481
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1482
                                pkt.flags |= PKT_FLAG_KEY;
1483
                            if (ost->logfile && enc->stats_out) {
1484
                                fprintf(ost->logfile, "%s", enc->stats_out);
1485
                            }
1486
                            break;
1487
                        default:
1488
                            ret=-1;
1489
                        }
1490

    
1491
                        if(ret<=0)
1492
                            break;
1493
                        pkt.data= bit_buffer;
1494
                        pkt.size= ret;
1495
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1496
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1497
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1498
                    }
1499
                }
1500
            }
1501
        }
1502
    }
1503

    
1504
    return 0;
1505
 fail_decode:
1506
    return -1;
1507
}
1508

    
1509
static void print_sdp(AVFormatContext **avc, int n)
1510
{
1511
    char sdp[2048];
1512

    
1513
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1514
    printf("SDP:\n%s\n", sdp);
1515
    fflush(stdout);
1516
}
1517

    
1518
static int stream_index_from_inputs(AVFormatContext **input_files,
1519
                                    int nb_input_files,
1520
                                    AVInputFile *file_table,
1521
                                    AVInputStream **ist_table,
1522
                                    enum CodecType type,
1523
                                    int programid)
1524
{
1525
    int p, q, z;
1526
    for(z=0; z<nb_input_files; z++) {
1527
        AVFormatContext *ic = input_files[z];
1528
        for(p=0; p<ic->nb_programs; p++) {
1529
            AVProgram *program = ic->programs[p];
1530
            if(program->id != programid)
1531
                continue;
1532
            for(q=0; q<program->nb_stream_indexes; q++) {
1533
                int sidx = program->stream_index[q];
1534
                int ris = file_table[z].ist_index + sidx;
1535
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1536
                    return ris;
1537
            }
1538
        }
1539
    }
1540

    
1541
    return -1;
1542
}
1543

    
1544
/*
1545
 * The following code is the main loop of the file converter
1546
 */
1547
static int av_encode(AVFormatContext **output_files,
1548
                     int nb_output_files,
1549
                     AVFormatContext **input_files,
1550
                     int nb_input_files,
1551
                     AVStreamMap *stream_maps, int nb_stream_maps)
1552
{
1553
    int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1554
    AVFormatContext *is, *os;
1555
    AVCodecContext *codec, *icodec;
1556
    AVOutputStream *ost, **ost_table = NULL;
1557
    AVInputStream *ist, **ist_table = NULL;
1558
    AVInputFile *file_table;
1559
    int key;
1560
    int want_sdp = 1;
1561

    
1562
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1563
    if (!file_table)
1564
        goto fail;
1565

    
1566
    /* input stream init */
1567
    j = 0;
1568
    for(i=0;i<nb_input_files;i++) {
1569
        is = input_files[i];
1570
        file_table[i].ist_index = j;
1571
        file_table[i].nb_streams = is->nb_streams;
1572
        j += is->nb_streams;
1573
    }
1574
    nb_istreams = j;
1575

    
1576
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1577
    if (!ist_table)
1578
        goto fail;
1579

    
1580
    for(i=0;i<nb_istreams;i++) {
1581
        ist = av_mallocz(sizeof(AVInputStream));
1582
        if (!ist)
1583
            goto fail;
1584
        ist_table[i] = ist;
1585
    }
1586
    j = 0;
1587
    for(i=0;i<nb_input_files;i++) {
1588
        is = input_files[i];
1589
        for(k=0;k<is->nb_streams;k++) {
1590
            ist = ist_table[j++];
1591
            ist->st = is->streams[k];
1592
            ist->file_index = i;
1593
            ist->index = k;
1594
            ist->discard = 1; /* the stream is discarded by default
1595
                                 (changed later) */
1596

    
1597
            if (rate_emu) {
1598
                ist->start = av_gettime();
1599
            }
1600
        }
1601
    }
1602

    
1603
    /* output stream init */
1604
    nb_ostreams = 0;
1605
    for(i=0;i<nb_output_files;i++) {
1606
        os = output_files[i];
1607
        if (!os->nb_streams) {
1608
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1609
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1610
            av_exit(1);
1611
        }
1612
        nb_ostreams += os->nb_streams;
1613
    }
1614
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1615
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1616
        av_exit(1);
1617
    }
1618

    
1619
    /* Sanity check the mapping args -- do the input files & streams exist? */
1620
    for(i=0;i<nb_stream_maps;i++) {
1621
        int fi = stream_maps[i].file_index;
1622
        int si = stream_maps[i].stream_index;
1623

    
1624
        if (fi < 0 || fi > nb_input_files - 1 ||
1625
            si < 0 || si > file_table[fi].nb_streams - 1) {
1626
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1627
            av_exit(1);
1628
        }
1629
        fi = stream_maps[i].sync_file_index;
1630
        si = stream_maps[i].sync_stream_index;
1631
        if (fi < 0 || fi > nb_input_files - 1 ||
1632
            si < 0 || si > file_table[fi].nb_streams - 1) {
1633
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1634
            av_exit(1);
1635
        }
1636
    }
1637

    
1638
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1639
    if (!ost_table)
1640
        goto fail;
1641
    for(i=0;i<nb_ostreams;i++) {
1642
        ost = av_mallocz(sizeof(AVOutputStream));
1643
        if (!ost)
1644
            goto fail;
1645
        ost_table[i] = ost;
1646
    }
1647

    
1648
    n = 0;
1649
    for(k=0;k<nb_output_files;k++) {
1650
        os = output_files[k];
1651
        for(i=0;i<os->nb_streams;i++,n++) {
1652
            int found;
1653
            ost = ost_table[n];
1654
            ost->file_index = k;
1655
            ost->index = i;
1656
            ost->st = os->streams[i];
1657
            if (nb_stream_maps > 0) {
1658
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1659
                    stream_maps[n].stream_index;
1660

    
1661
                /* Sanity check that the stream types match */
1662
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1663
                    int i= ost->file_index;
1664
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1665
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1666
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1667
                        ost->file_index, ost->index);
1668
                    av_exit(1);
1669
                }
1670

    
1671
            } else {
1672
                if(opt_programid) {
1673
                    found = 0;
1674
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1675
                    if(j != -1) {
1676
                        ost->source_index = j;
1677
                        found = 1;
1678
                    }
1679
                } else {
1680
                    /* get corresponding input stream index : we select the first one with the right type */
1681
                    found = 0;
1682
                    for(j=0;j<nb_istreams;j++) {
1683
                        ist = ist_table[j];
1684
                        if (ist->discard &&
1685
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1686
                            ost->source_index = j;
1687
                            found = 1;
1688
                            break;
1689
                        }
1690
                    }
1691
                }
1692

    
1693
                if (!found) {
1694
                    if(! opt_programid) {
1695
                        /* try again and reuse existing stream */
1696
                        for(j=0;j<nb_istreams;j++) {
1697
                            ist = ist_table[j];
1698
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1699
                                ost->source_index = j;
1700
                                found = 1;
1701
                            }
1702
                        }
1703
                    }
1704
                    if (!found) {
1705
                        int i= ost->file_index;
1706
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1707
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1708
                                ost->file_index, ost->index);
1709
                        av_exit(1);
1710
                    }
1711
                }
1712
            }
1713
            ist = ist_table[ost->source_index];
1714
            ist->discard = 0;
1715
            ost->sync_ist = (nb_stream_maps > 0) ?
1716
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1717
                         stream_maps[n].sync_stream_index] : ist;
1718
        }
1719
    }
1720

    
1721
    /* for each output stream, we compute the right encoding parameters */
1722
    for(i=0;i<nb_ostreams;i++) {
1723
        ost = ost_table[i];
1724
        os = output_files[ost->file_index];
1725
        ist = ist_table[ost->source_index];
1726

    
1727
        codec = ost->st->codec;
1728
        icodec = ist->st->codec;
1729

    
1730
        if (!ost->st->language[0])
1731
            av_strlcpy(ost->st->language, ist->st->language,
1732
                       sizeof(ost->st->language));
1733

    
1734
        ost->st->disposition = ist->st->disposition;
1735

    
1736
        if (ost->st->stream_copy) {
1737
            /* if stream_copy is selected, no need to decode or encode */
1738
            codec->codec_id = icodec->codec_id;
1739
            codec->codec_type = icodec->codec_type;
1740

    
1741
            if(!codec->codec_tag){
1742
                if(   !os->oformat->codec_tag
1743
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1744
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1745
                    codec->codec_tag = icodec->codec_tag;
1746
            }
1747

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

    
1866
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1867
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1868
                         i);
1869
                if (codec->flags & CODEC_FLAG_PASS1) {
1870
                    f = fopen(logfilename, "w");
1871
                    if (!f) {
1872
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1873
                        av_exit(1);
1874
                    }
1875
                    ost->logfile = f;
1876
                } else {
1877
                    /* read the log file */
1878
                    f = fopen(logfilename, "r");
1879
                    if (!f) {
1880
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1881
                        av_exit(1);
1882
                    }
1883
                    fseek(f, 0, SEEK_END);
1884
                    size = ftell(f);
1885
                    fseek(f, 0, SEEK_SET);
1886
                    logbuffer = av_malloc(size + 1);
1887
                    if (!logbuffer) {
1888
                        fprintf(stderr, "Could not allocate log buffer\n");
1889
                        av_exit(1);
1890
                    }
1891
                    size = fread(logbuffer, 1, size, f);
1892
                    fclose(f);
1893
                    logbuffer[size] = '\0';
1894
                    codec->stats_in = logbuffer;
1895
                }
1896
            }
1897
        }
1898
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1899
            int size= codec->width * codec->height;
1900
            bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1901
        }
1902
    }
1903

    
1904
    if (!bit_buffer)
1905
        bit_buffer = av_malloc(bit_buffer_size);
1906
    if (!bit_buffer)
1907
        goto fail;
1908

    
1909
    /* dump the file output parameters - cannot be done before in case
1910
       of stream copy */
1911
    for(i=0;i<nb_output_files;i++) {
1912
        dump_format(output_files[i], i, output_files[i]->filename, 1);
1913
    }
1914

    
1915
    /* dump the stream mapping */
1916
    if (verbose >= 0) {
1917
        fprintf(stderr, "Stream mapping:\n");
1918
        for(i=0;i<nb_ostreams;i++) {
1919
            ost = ost_table[i];
1920
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1921
                    ist_table[ost->source_index]->file_index,
1922
                    ist_table[ost->source_index]->index,
1923
                    ost->file_index,
1924
                    ost->index);
1925
            if (ost->sync_ist != ist_table[ost->source_index])
1926
                fprintf(stderr, " [sync #%d.%d]",
1927
                        ost->sync_ist->file_index,
1928
                        ost->sync_ist->index);
1929
            fprintf(stderr, "\n");
1930
        }
1931
    }
1932

    
1933
    /* open each encoder */
1934
    for(i=0;i<nb_ostreams;i++) {
1935
        ost = ost_table[i];
1936
        if (ost->encoding_needed) {
1937
            AVCodec *codec = output_codecs[i];
1938
            if (!codec)
1939
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
1940
            if (!codec) {
1941
                fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1942
                        ost->file_index, ost->index);
1943
                av_exit(1);
1944
            }
1945
            if (avcodec_open(ost->st->codec, codec) < 0) {
1946
                fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1947
                        ost->file_index, ost->index);
1948
                av_exit(1);
1949
            }
1950
            extra_size += ost->st->codec->extradata_size;
1951
        }
1952
    }
1953

    
1954
    /* open each decoder */
1955
    for(i=0;i<nb_istreams;i++) {
1956
        ist = ist_table[i];
1957
        if (ist->decoding_needed) {
1958
            AVCodec *codec = input_codecs[i];
1959
            if (!codec)
1960
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
1961
            if (!codec) {
1962
                fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1963
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1964
                av_exit(1);
1965
            }
1966
            if (avcodec_open(ist->st->codec, codec) < 0) {
1967
                fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1968
                        ist->file_index, ist->index);
1969
                av_exit(1);
1970
            }
1971
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1972
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1973
        }
1974
    }
1975

    
1976
    /* init pts */
1977
    for(i=0;i<nb_istreams;i++) {
1978
        ist = ist_table[i];
1979
        is = input_files[ist->file_index];
1980
        ist->pts = 0;
1981
        ist->next_pts = AV_NOPTS_VALUE;
1982
        ist->is_start = 1;
1983
    }
1984

    
1985
    /* set meta data information from input file if required */
1986
    for (i=0;i<nb_meta_data_maps;i++) {
1987
        AVFormatContext *out_file;
1988
        AVFormatContext *in_file;
1989

    
1990
        int out_file_index = meta_data_maps[i].out_file;
1991
        int in_file_index = meta_data_maps[i].in_file;
1992
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1993
            fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1994
            ret = AVERROR(EINVAL);
1995
            goto fail;
1996
        }
1997
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1998
            fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1999
            ret = AVERROR(EINVAL);
2000
            goto fail;
2001
        }
2002

    
2003
        out_file = output_files[out_file_index];
2004
        in_file = input_files[in_file_index];
2005

    
2006
        strcpy(out_file->title, in_file->title);
2007
        strcpy(out_file->author, in_file->author);
2008
        strcpy(out_file->copyright, in_file->copyright);
2009
        strcpy(out_file->comment, in_file->comment);
2010
        strcpy(out_file->album, in_file->album);
2011
        out_file->year = in_file->year;
2012
        out_file->track = in_file->track;
2013
        strcpy(out_file->genre, in_file->genre);
2014
    }
2015

    
2016
    /* open files and write file headers */
2017
    for(i=0;i<nb_output_files;i++) {
2018
        os = output_files[i];
2019
        if (av_write_header(os) < 0) {
2020
            fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
2021
            ret = AVERROR(EINVAL);
2022
            goto fail;
2023
        }
2024
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2025
            want_sdp = 0;
2026
        }
2027
    }
2028
    if (want_sdp) {
2029
        print_sdp(output_files, nb_output_files);
2030
    }
2031

    
2032
    if (!using_stdin && verbose >= 0) {
2033
        fprintf(stderr, "Press [q] to stop encoding\n");
2034
        url_set_interrupt_cb(decode_interrupt_cb);
2035
    }
2036
    term_init();
2037

    
2038
    key = -1;
2039
    timer_start = av_gettime();
2040

    
2041
    for(; received_sigterm == 0;) {
2042
        int file_index, ist_index;
2043
        AVPacket pkt;
2044
        double ipts_min;
2045
        double opts_min;
2046

    
2047
    redo:
2048
        ipts_min= 1e100;
2049
        opts_min= 1e100;
2050
        /* if 'q' pressed, exits */
2051
        if (!using_stdin) {
2052
            if (q_pressed)
2053
                break;
2054
            /* read_key() returns 0 on EOF */
2055
            key = read_key();
2056
            if (key == 'q')
2057
                break;
2058
        }
2059

    
2060
        /* select the stream that we must read now by looking at the
2061
           smallest output pts */
2062
        file_index = -1;
2063
        for(i=0;i<nb_ostreams;i++) {
2064
            double ipts, opts;
2065
            ost = ost_table[i];
2066
            os = output_files[ost->file_index];
2067
            ist = ist_table[ost->source_index];
2068
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2069
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2070
            else
2071
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2072
            ipts = (double)ist->pts;
2073
            if (!file_table[ist->file_index].eof_reached){
2074
                if(ipts < ipts_min) {
2075
                    ipts_min = ipts;
2076
                    if(input_sync ) file_index = ist->file_index;
2077
                }
2078
                if(opts < opts_min) {
2079
                    opts_min = opts;
2080
                    if(!input_sync) file_index = ist->file_index;
2081
                }
2082
            }
2083
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2084
                file_index= -1;
2085
                break;
2086
            }
2087
        }
2088
        /* if none, if is finished */
2089
        if (file_index < 0) {
2090
            break;
2091
        }
2092

    
2093
        /* finish if recording time exhausted */
2094
        if (opts_min >= (recording_time / 1000000.0))
2095
            break;
2096

    
2097
        /* finish if limit size exhausted */
2098
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2099
            break;
2100

    
2101
        /* read a frame from it and output it in the fifo */
2102
        is = input_files[file_index];
2103
        ret= av_read_frame(is, &pkt);
2104
        if(ret == AVERROR(EAGAIN) && strcmp(is->iformat->name, "ffm"))
2105
            continue;
2106
        if (ret < 0) {
2107
            file_table[file_index].eof_reached = 1;
2108
            if (opt_shortest)
2109
                break;
2110
            else
2111
                continue;
2112
        }
2113

    
2114
        if (do_pkt_dump) {
2115
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2116
        }
2117
        /* the following test is needed in case new streams appear
2118
           dynamically in stream : we ignore them */
2119
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2120
            goto discard_packet;
2121
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2122
        ist = ist_table[ist_index];
2123
        if (ist->discard)
2124
            goto discard_packet;
2125

    
2126
        if (pkt.dts != AV_NOPTS_VALUE)
2127
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2128
        if (pkt.pts != AV_NOPTS_VALUE)
2129
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2130

    
2131
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2132
            if(pkt.pts != AV_NOPTS_VALUE)
2133
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2134
            if(pkt.dts != AV_NOPTS_VALUE)
2135
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2136
        }
2137

    
2138
//        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);
2139
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2140
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2141
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2142
            int64_t delta= pkt_dts - ist->next_pts;
2143
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2144
                input_files_ts_offset[ist->file_index]-= delta;
2145
                if (verbose > 2)
2146
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2147
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2148
                if(pkt.pts != AV_NOPTS_VALUE)
2149
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2150
            }
2151
        }
2152

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

    
2156
            if (verbose >= 0)
2157
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2158
                        ist->file_index, ist->index);
2159
            if (exit_on_error)
2160
                av_exit(1);
2161
            av_free_packet(&pkt);
2162
            goto redo;
2163
        }
2164

    
2165
    discard_packet:
2166
        av_free_packet(&pkt);
2167

    
2168
        /* dump report by using the output first video and audio streams */
2169
        print_report(output_files, ost_table, nb_ostreams, 0);
2170
    }
2171

    
2172
    /* at the end of stream, we must flush the decoder buffers */
2173
    for(i=0;i<nb_istreams;i++) {
2174
        ist = ist_table[i];
2175
        if (ist->decoding_needed) {
2176
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2177
        }
2178
    }
2179

    
2180
    term_exit();
2181

    
2182
    /* write the trailer if needed and close file */
2183
    for(i=0;i<nb_output_files;i++) {
2184
        os = output_files[i];
2185
        av_write_trailer(os);
2186
    }
2187

    
2188
    /* dump report by using the first video and audio streams */
2189
    print_report(output_files, ost_table, nb_ostreams, 1);
2190

    
2191
    /* close each encoder */
2192
    for(i=0;i<nb_ostreams;i++) {
2193
        ost = ost_table[i];
2194
        if (ost->encoding_needed) {
2195
            av_freep(&ost->st->codec->stats_in);
2196
            avcodec_close(ost->st->codec);
2197
        }
2198
    }
2199

    
2200
    /* close each decoder */
2201
    for(i=0;i<nb_istreams;i++) {
2202
        ist = ist_table[i];
2203
        if (ist->decoding_needed) {
2204
            avcodec_close(ist->st->codec);
2205
        }
2206
    }
2207

    
2208
    /* finished ! */
2209

    
2210
    ret = 0;
2211
 fail1:
2212
    av_freep(&bit_buffer);
2213
    av_free(file_table);
2214

    
2215
    if (ist_table) {
2216
        for(i=0;i<nb_istreams;i++) {
2217
            ist = ist_table[i];
2218
            av_free(ist);
2219
        }
2220
        av_free(ist_table);
2221
    }
2222
    if (ost_table) {
2223
        for(i=0;i<nb_ostreams;i++) {
2224
            ost = ost_table[i];
2225
            if (ost) {
2226
                if (ost->logfile) {
2227
                    fclose(ost->logfile);
2228
                    ost->logfile = NULL;
2229
                }
2230
                av_fifo_free(&ost->fifo); /* works even if fifo is not
2231
                                             initialized but set to zero */
2232
                av_free(ost->pict_tmp.data[0]);
2233
                if (ost->video_resample)
2234
                    sws_freeContext(ost->img_resample_ctx);
2235
                if (ost->resample)
2236
                    audio_resample_close(ost->resample);
2237
                if (ost->reformat_ctx)
2238
                    av_audio_convert_free(ost->reformat_ctx);
2239
                av_free(ost);
2240
            }
2241
        }
2242
        av_free(ost_table);
2243
    }
2244
    return ret;
2245
 fail:
2246
    ret = AVERROR(ENOMEM);
2247
    goto fail1;
2248
}
2249

    
2250
#if 0
2251
int file_read(const char *filename)
2252
{
2253
    URLContext *h;
2254
    unsigned char buffer[1024];
2255
    int len, i;
2256

2257
    if (url_open(&h, filename, O_RDONLY) < 0) {
2258
        printf("could not open '%s'\n", filename);
2259
        return -1;
2260
    }
2261
    for(;;) {
2262
        len = url_read(h, buffer, sizeof(buffer));
2263
        if (len <= 0)
2264
            break;
2265
        for(i=0;i<len;i++) putchar(buffer[i]);
2266
    }
2267
    url_close(h);
2268
    return 0;
2269
}
2270
#endif
2271

    
2272
static void opt_format(const char *arg)
2273
{
2274
    /* compatibility stuff for pgmyuv */
2275
    if (!strcmp(arg, "pgmyuv")) {
2276
        pgmyuv_compatibility_hack=1;
2277
//        opt_image_format(arg);
2278
        arg = "image2";
2279
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2280
    }
2281

    
2282
    file_iformat = av_find_input_format(arg);
2283
    file_oformat = guess_format(arg, NULL, NULL);
2284
    if (!file_iformat && !file_oformat) {
2285
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2286
        av_exit(1);
2287
    }
2288
}
2289

    
2290
static void opt_video_rc_override_string(const char *arg)
2291
{
2292
    video_rc_override_string = arg;
2293
}
2294

    
2295
static int opt_me_threshold(const char *opt, const char *arg)
2296
{
2297
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2298
    return 0;
2299
}
2300

    
2301
static int opt_verbose(const char *opt, const char *arg)
2302
{
2303
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2304
    av_log_set_level(verbose);
2305
    return 0;
2306
}
2307

    
2308
static int opt_frame_rate(const char *opt, const char *arg)
2309
{
2310
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2311
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2312
        av_exit(1);
2313
    }
2314
    return 0;
2315
}
2316

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

    
2321
    opt_default(opt, arg);
2322

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

    
2326
    return 0;
2327
}
2328

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

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

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

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

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

    
2413

    
2414
#define SCALEBITS 10
2415
#define ONE_HALF  (1 << (SCALEBITS - 1))
2416
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2417

    
2418
#define RGB_TO_Y(r, g, b) \
2419
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2420
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2421

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

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

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

    
2436
    r = (rgb >> 16);
2437
    g = ((rgb >> 8) & 255);
2438
    b = (rgb & 255);
2439

    
2440
    padcolor[0] = RGB_TO_Y(r,g,b);
2441
    padcolor[1] = RGB_TO_U(r,g,b,0);
2442
    padcolor[2] = RGB_TO_V(r,g,b,0);
2443
}
2444

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

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

    
2471

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

    
2485

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

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

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

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

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

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

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

    
2553
static void opt_top_field_first(const char *arg)
2554
{
2555
    top_field_first= atoi(arg);
2556
}
2557

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

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

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

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

    
2590
static void opt_video_channel(const char *arg)
2591
{
2592
    video_channel = strtol(arg, NULL, 0);
2593
}
2594

    
2595
static void opt_video_standard(const char *arg)
2596
{
2597
    video_standard = av_strdup(arg);
2598
}
2599

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

    
2611
static void opt_audio_codec(const char *arg)
2612
{
2613
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2614
}
2615

    
2616
static void opt_audio_tag(const char *arg)
2617
{
2618
    char *tail;
2619
    audio_codec_tag= strtol(arg, &tail, 0);
2620

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

    
2625
static void opt_video_tag(const char *arg)
2626
{
2627
    char *tail;
2628
    video_codec_tag= strtol(arg, &tail, 0);
2629

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

    
2634
#if CONFIG_VHOOK
2635
static void add_frame_hooker(const char *arg)
2636
{
2637
    int argc = 0;
2638
    char *argv[64];
2639
    int i;
2640
    char *args = av_strdup(arg);
2641

    
2642
    using_vhook = 1;
2643

    
2644
    argv[0] = strtok(args, " ");
2645
    while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2646
    }
2647

    
2648
    i = frame_hook_add(argc, argv);
2649

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

    
2657
static void opt_video_codec(const char *arg)
2658
{
2659
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2660
}
2661

    
2662
static void opt_subtitle_codec(const char *arg)
2663
{
2664
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2665
}
2666

    
2667
static void opt_map(const char *arg)
2668
{
2669
    AVStreamMap *m;
2670
    char *p;
2671

    
2672
    m = &stream_maps[nb_stream_maps++];
2673

    
2674
    m->file_index = strtol(arg, &p, 0);
2675
    if (*p)
2676
        p++;
2677

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

    
2691
static void opt_map_meta_data(const char *arg)
2692
{
2693
    AVMetaDataMap *m;
2694
    char *p;
2695

    
2696
    m = &meta_data_maps[nb_meta_data_maps++];
2697

    
2698
    m->out_file = strtol(arg, &p, 0);
2699
    if (*p)
2700
        p++;
2701

    
2702
    m->in_file = strtol(p, &p, 0);
2703
}
2704

    
2705
static void opt_input_ts_scale(const char *arg)
2706
{
2707
    unsigned int stream;
2708
    double scale;
2709
    char *p;
2710

    
2711
    stream = strtol(arg, &p, 0);
2712
    if (*p)
2713
        p++;
2714
    scale= strtod(p, &p);
2715

    
2716
    if(stream >= MAX_STREAMS)
2717
        av_exit(1);
2718

    
2719
    input_files_ts_scale[nb_input_files][stream]= scale;
2720
}
2721

    
2722
static int opt_recording_time(const char *opt, const char *arg)
2723
{
2724
    recording_time = parse_time_or_die(opt, arg, 1);
2725
    return 0;
2726
}
2727

    
2728
static int opt_start_time(const char *opt, const char *arg)
2729
{
2730
    start_time = parse_time_or_die(opt, arg, 1);
2731
    return 0;
2732
}
2733

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

    
2740
static int opt_input_ts_offset(const char *opt, const char *arg)
2741
{
2742
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2743
    return 0;
2744
}
2745

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

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

    
2767
static void opt_input_file(const char *filename)
2768
{
2769
    AVFormatContext *ic;
2770
    AVFormatParameters params, *ap = &params;
2771
    int err, i, ret, rfps, rfps_base;
2772
    int64_t timestamp;
2773

    
2774
    if (!strcmp(filename, "-"))
2775
        filename = "pipe:";
2776

    
2777
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2778
                    !strcmp(filename, "/dev/stdin");
2779

    
2780
    /* get default parameters from command line */
2781
    ic = avformat_alloc_context();
2782

    
2783
    memset(ap, 0, sizeof(*ap));
2784
    ap->prealloced_context = 1;
2785
    ap->sample_rate = audio_sample_rate;
2786
    ap->channels = audio_channels;
2787
    ap->time_base.den = frame_rate.num;
2788
    ap->time_base.num = frame_rate.den;
2789
    ap->width = frame_width + frame_padleft + frame_padright;
2790
    ap->height = frame_height + frame_padtop + frame_padbottom;
2791
    ap->pix_fmt = frame_pix_fmt;
2792
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2793
    ap->channel = video_channel;
2794
    ap->standard = video_standard;
2795
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2796
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2797
    if(pgmyuv_compatibility_hack)
2798
        ap->video_codec_id= CODEC_ID_PGMYUV;
2799

    
2800
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2801

    
2802
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2803
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2804
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2805

    
2806
    /* open the input file with generic libav function */
2807
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2808
    if (err < 0) {
2809
        print_error(filename, err);
2810
        av_exit(1);
2811
    }
2812
    if(opt_programid) {
2813
        int i;
2814
        for(i=0; i<ic->nb_programs; i++)
2815
            if(ic->programs[i]->id != opt_programid)
2816
                ic->programs[i]->discard = AVDISCARD_ALL;
2817
    }
2818

    
2819
    ic->loop_input = loop_input;
2820

    
2821
    /* If not enough info to get the stream parameters, we decode the
2822
       first frames to get it. (used in mpeg case for example) */
2823
    ret = av_find_stream_info(ic);
2824
    if (ret < 0 && verbose >= 0) {
2825
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2826
        av_exit(1);
2827
    }
2828

    
2829
    timestamp = start_time;
2830
    /* add the stream start time */
2831
    if (ic->start_time != AV_NOPTS_VALUE)
2832
        timestamp += ic->start_time;
2833

    
2834
    /* if seeking requested, we execute it */
2835
    if (start_time != 0) {
2836
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2837
        if (ret < 0) {
2838
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2839
                    filename, (double)timestamp / AV_TIME_BASE);
2840
        }
2841
        /* reset seek info */
2842
        start_time = 0;
2843
    }
2844

    
2845
    /* update the current parameters so that they match the one of the input stream */
2846
    for(i=0;i<ic->nb_streams;i++) {
2847
        AVCodecContext *enc = ic->streams[i]->codec;
2848
        if(thread_count>1)
2849
            avcodec_thread_init(enc, thread_count);
2850
        enc->thread_count= thread_count;
2851
        switch(enc->codec_type) {
2852
        case CODEC_TYPE_AUDIO:
2853
            set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2854
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2855
            channel_layout = enc->channel_layout;
2856
            audio_channels = enc->channels;
2857
            audio_sample_rate = enc->sample_rate;
2858
            audio_sample_fmt = enc->sample_fmt;
2859
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2860
            if(audio_disable)
2861
                ic->streams[i]->discard= AVDISCARD_ALL;
2862
            break;
2863
        case CODEC_TYPE_VIDEO:
2864
            set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2865
            frame_height = enc->height;
2866
            frame_width = enc->width;
2867
            if(ic->streams[i]->sample_aspect_ratio.num)
2868
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2869
            else
2870
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2871
            frame_aspect_ratio *= (float) enc->width / enc->height;
2872
            frame_pix_fmt = enc->pix_fmt;
2873
            rfps      = ic->streams[i]->r_frame_rate.num;
2874
            rfps_base = ic->streams[i]->r_frame_rate.den;
2875
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2876
            if(me_threshold)
2877
                enc->debug |= FF_DEBUG_MV;
2878

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

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

    
2885
                    (float)rfps / rfps_base, rfps, rfps_base);
2886
            }
2887
            /* update the current frame rate to match the stream frame rate */
2888
            frame_rate.num = rfps;
2889
            frame_rate.den = rfps_base;
2890

    
2891
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2892
            if(video_disable)
2893
                ic->streams[i]->discard= AVDISCARD_ALL;
2894
            else if(video_discard)
2895
                ic->streams[i]->discard= video_discard;
2896
            break;
2897
        case CODEC_TYPE_DATA:
2898
            break;
2899
        case CODEC_TYPE_SUBTITLE:
2900
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2901
            if(subtitle_disable)
2902
                ic->streams[i]->discard = AVDISCARD_ALL;
2903
            break;
2904
        case CODEC_TYPE_ATTACHMENT:
2905
        case CODEC_TYPE_UNKNOWN:
2906
            nb_icodecs++;
2907
            break;
2908
        default:
2909
            abort();
2910
        }
2911
    }
2912

    
2913
    input_files[nb_input_files] = ic;
2914
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2915
    /* dump the file content */
2916
    if (verbose >= 0)
2917
        dump_format(ic, nb_input_files, filename, 0);
2918

    
2919
    nb_input_files++;
2920
    file_iformat = NULL;
2921
    file_oformat = NULL;
2922

    
2923
    video_channel = 0;
2924

    
2925
    av_freep(&video_codec_name);
2926
    av_freep(&audio_codec_name);
2927
    av_freep(&subtitle_codec_name);
2928
}
2929

    
2930
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2931
                                         int *has_subtitle_ptr)
2932
{
2933
    int has_video, has_audio, has_subtitle, i, j;
2934
    AVFormatContext *ic;
2935

    
2936
    has_video = 0;
2937
    has_audio = 0;
2938
    has_subtitle = 0;
2939
    for(j=0;j<nb_input_files;j++) {
2940
        ic = input_files[j];
2941
        for(i=0;i<ic->nb_streams;i++) {
2942
            AVCodecContext *enc = ic->streams[i]->codec;
2943
            switch(enc->codec_type) {
2944
            case CODEC_TYPE_AUDIO:
2945
                has_audio = 1;
2946
                break;
2947
            case CODEC_TYPE_VIDEO:
2948
                has_video = 1;
2949
                break;
2950
            case CODEC_TYPE_SUBTITLE:
2951
                has_subtitle = 1;
2952
                break;
2953
            case CODEC_TYPE_DATA:
2954
            case CODEC_TYPE_ATTACHMENT:
2955
            case CODEC_TYPE_UNKNOWN:
2956
                break;
2957
            default:
2958
                abort();
2959
            }
2960
        }
2961
    }
2962
    *has_video_ptr = has_video;
2963
    *has_audio_ptr = has_audio;
2964
    *has_subtitle_ptr = has_subtitle;
2965
}
2966

    
2967
static void new_video_stream(AVFormatContext *oc)
2968
{
2969
    AVStream *st;
2970
    AVCodecContext *video_enc;
2971
    int codec_id;
2972

    
2973
    st = av_new_stream(oc, oc->nb_streams);
2974
    if (!st) {
2975
        fprintf(stderr, "Could not alloc stream\n");
2976
        av_exit(1);
2977
    }
2978
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2979
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2980
    video_bitstream_filters= NULL;
2981

    
2982
    if(thread_count>1)
2983
        avcodec_thread_init(st->codec, thread_count);
2984

    
2985
    video_enc = st->codec;
2986

    
2987
    if(video_codec_tag)
2988
        video_enc->codec_tag= video_codec_tag;
2989

    
2990
    if(   (video_global_header&1)
2991
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2992
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2993
        avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2994
    }
2995
    if(video_global_header&2){
2996
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2997
        avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2998
    }
2999

    
3000
    if (video_stream_copy) {
3001
        st->stream_copy = 1;
3002
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3003
        video_enc->sample_aspect_ratio =
3004
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3005
    } else {
3006
        const char *p;
3007
        int i;
3008
        AVCodec *codec;
3009
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3010

    
3011
        if (video_codec_name) {
3012
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3013
            codec = avcodec_find_encoder_by_name(video_codec_name);
3014
            output_codecs[nb_ocodecs] = codec;
3015
        } else {
3016
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3017
            codec = avcodec_find_encoder(codec_id);
3018
        }
3019

    
3020
        video_enc->codec_id = codec_id;
3021

    
3022
        set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3023

    
3024
        if (codec && codec->supported_framerates && !force_fps)
3025
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3026
        video_enc->time_base.den = fps.num;
3027
        video_enc->time_base.num = fps.den;
3028

    
3029
        video_enc->width = frame_width + frame_padright + frame_padleft;
3030
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3031
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3032
        video_enc->pix_fmt = frame_pix_fmt;
3033
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3034

    
3035
        if(codec && codec->pix_fmts){
3036
            const enum PixelFormat *p= codec->pix_fmts;
3037
            for(; *p!=-1; p++){
3038
                if(*p == video_enc->pix_fmt)
3039
                    break;
3040
            }
3041
            if(*p == -1)
3042
                video_enc->pix_fmt = codec->pix_fmts[0];
3043
        }
3044

    
3045
        if (intra_only)
3046
            video_enc->gop_size = 0;
3047
        if (video_qscale || same_quality) {
3048
            video_enc->flags |= CODEC_FLAG_QSCALE;
3049
            video_enc->global_quality=
3050
                st->quality = FF_QP2LAMBDA * video_qscale;
3051
        }
3052

    
3053
        if(intra_matrix)
3054
            video_enc->intra_matrix = intra_matrix;
3055
        if(inter_matrix)
3056
            video_enc->inter_matrix = inter_matrix;
3057

    
3058
        video_enc->thread_count = thread_count;
3059
        p= video_rc_override_string;
3060
        for(i=0; p; i++){
3061
            int start, end, q;
3062
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3063
            if(e!=3){
3064
                fprintf(stderr, "error parsing rc_override\n");
3065
                av_exit(1);
3066
            }
3067
            video_enc->rc_override=
3068
                av_realloc(video_enc->rc_override,
3069
                           sizeof(RcOverride)*(i+1));
3070
            video_enc->rc_override[i].start_frame= start;
3071
            video_enc->rc_override[i].end_frame  = end;
3072
            if(q>0){
3073
                video_enc->rc_override[i].qscale= q;
3074
                video_enc->rc_override[i].quality_factor= 1.0;
3075
            }
3076
            else{
3077
                video_enc->rc_override[i].qscale= 0;
3078
                video_enc->rc_override[i].quality_factor= -q/100.0;
3079
            }
3080
            p= strchr(p, '/');
3081
            if(p) p++;
3082
        }
3083
        video_enc->rc_override_count=i;
3084
        if (!video_enc->rc_initial_buffer_occupancy)
3085
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3086
        video_enc->me_threshold= me_threshold;
3087
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3088

    
3089
        if (do_psnr)
3090
            video_enc->flags|= CODEC_FLAG_PSNR;
3091

    
3092
        /* two pass mode */
3093
        if (do_pass) {
3094
            if (do_pass == 1) {
3095
                video_enc->flags |= CODEC_FLAG_PASS1;
3096
            } else {
3097
                video_enc->flags |= CODEC_FLAG_PASS2;
3098
            }
3099
        }
3100
    }
3101
    nb_ocodecs++;
3102

    
3103
    /* reset some key parameters */
3104
    video_disable = 0;
3105
    av_freep(&video_codec_name);
3106
    video_stream_copy = 0;
3107
}
3108

    
3109
static void new_audio_stream(AVFormatContext *oc)
3110
{
3111
    AVStream *st;
3112
    AVCodecContext *audio_enc;
3113
    int codec_id;
3114

    
3115
    st = av_new_stream(oc, oc->nb_streams);
3116
    if (!st) {
3117
        fprintf(stderr, "Could not alloc stream\n");
3118
        av_exit(1);
3119
    }
3120
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3121

    
3122
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3123
    audio_bitstream_filters= NULL;
3124

    
3125
    if(thread_count>1)
3126
        avcodec_thread_init(st->codec, thread_count);
3127

    
3128
    audio_enc = st->codec;
3129
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3130

    
3131
    if(audio_codec_tag)
3132
        audio_enc->codec_tag= audio_codec_tag;
3133

    
3134
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3135
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3136
        avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3137
    }
3138
    if (audio_stream_copy) {
3139
        st->stream_copy = 1;
3140
        audio_enc->channels = audio_channels;
3141
    } else {
3142
        AVCodec *codec;
3143

    
3144
        set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3145

    
3146
        if (audio_codec_name) {
3147
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3148
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3149
            output_codecs[nb_ocodecs] = codec;
3150
        } else {
3151
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3152
            codec = avcodec_find_encoder(codec_id);
3153
        }
3154
        audio_enc->codec_id = codec_id;
3155

    
3156
        if (audio_qscale > QSCALE_NONE) {
3157
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3158
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3159
        }
3160
        audio_enc->thread_count = thread_count;
3161
        audio_enc->channels = audio_channels;
3162
        audio_enc->sample_fmt = audio_sample_fmt;
3163
        audio_enc->channel_layout = channel_layout;
3164

    
3165
        if(codec && codec->sample_fmts){
3166
            const enum SampleFormat *p= codec->sample_fmts;
3167
            for(; *p!=-1; p++){
3168
                if(*p == audio_enc->sample_fmt)
3169
                    break;
3170
            }
3171
            if(*p == -1)
3172
                audio_enc->sample_fmt = codec->sample_fmts[0];
3173
        }
3174
    }
3175
    nb_ocodecs++;
3176
    audio_enc->sample_rate = audio_sample_rate;
3177
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3178
    if (audio_language) {
3179
        av_strlcpy(st->language, audio_language, sizeof(st->language));
3180
        av_free(audio_language);
3181
        audio_language = NULL;
3182
    }
3183

    
3184
    /* reset some key parameters */
3185
    audio_disable = 0;
3186
    av_freep(&audio_codec_name);
3187
    audio_stream_copy = 0;
3188
}
3189

    
3190
static void new_subtitle_stream(AVFormatContext *oc)
3191
{
3192
    AVStream *st;
3193
    AVCodecContext *subtitle_enc;
3194

    
3195
    st = av_new_stream(oc, oc->nb_streams);
3196
    if (!st) {
3197
        fprintf(stderr, "Could not alloc stream\n");
3198
        av_exit(1);
3199
    }
3200
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3201

    
3202
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3203
    subtitle_bitstream_filters= NULL;
3204

    
3205
    subtitle_enc = st->codec;
3206
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3207
    if (subtitle_stream_copy) {
3208
        st->stream_copy = 1;
3209
    } else {
3210
        set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3211
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3212
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3213
    }
3214
    nb_ocodecs++;
3215

    
3216
    if (subtitle_language) {
3217
        av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3218
        av_free(subtitle_language);
3219
        subtitle_language = NULL;
3220
    }
3221

    
3222
    subtitle_disable = 0;
3223
    av_freep(&subtitle_codec_name);
3224
    subtitle_stream_copy = 0;
3225
}
3226

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

    
3238
static void opt_new_video_stream(void)
3239
{
3240
    AVFormatContext *oc;
3241
    if (nb_output_files <= 0) {
3242
        fprintf(stderr, "At least one output file must be specified\n");
3243
        av_exit(1);
3244
    }
3245
    oc = output_files[nb_output_files - 1];
3246
    new_video_stream(oc);
3247
}
3248

    
3249
static void opt_new_subtitle_stream(void)
3250
{
3251
    AVFormatContext *oc;
3252
    if (nb_output_files <= 0) {
3253
        fprintf(stderr, "At least one output file must be specified\n");
3254
        av_exit(1);
3255
    }
3256
    oc = output_files[nb_output_files - 1];
3257
    new_subtitle_stream(oc);
3258
}
3259

    
3260
static void opt_output_file(const char *filename)
3261
{
3262
    AVFormatContext *oc;
3263
    int use_video, use_audio, use_subtitle;
3264
    int input_has_video, input_has_audio, input_has_subtitle;
3265
    AVFormatParameters params, *ap = &params;
3266

    
3267
    if (!strcmp(filename, "-"))
3268
        filename = "pipe:";
3269

    
3270
    oc = avformat_alloc_context();
3271

    
3272
    if (!file_oformat) {
3273
        file_oformat = guess_format(NULL, filename, NULL);
3274
        if (!file_oformat) {
3275
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3276
                    filename);
3277
            av_exit(1);
3278
        }
3279
    }
3280

    
3281
    oc->oformat = file_oformat;
3282
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3283

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

    
3298
        /* disable if no corresponding type found and at least one
3299
           input file */
3300
        if (nb_input_files > 0) {
3301
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3302
                                         &input_has_subtitle);
3303
            if (!input_has_video)
3304
                use_video = 0;
3305
            if (!input_has_audio)
3306
                use_audio = 0;
3307
            if (!input_has_subtitle)
3308
                use_subtitle = 0;
3309
        }
3310

    
3311
        /* manual disable */
3312
        if (audio_disable) {
3313
            use_audio = 0;
3314
        }
3315
        if (video_disable) {
3316
            use_video = 0;
3317
        }
3318
        if (subtitle_disable) {
3319
            use_subtitle = 0;
3320
        }
3321

    
3322
        if (use_video) {
3323
            new_video_stream(oc);
3324
        }
3325

    
3326
        if (use_audio) {
3327
            new_audio_stream(oc);
3328
        }
3329

    
3330
        if (use_subtitle) {
3331
            new_subtitle_stream(oc);
3332
        }
3333

    
3334
        oc->timestamp = rec_timestamp;
3335

    
3336
        if (str_title)
3337
            av_strlcpy(oc->title, str_title, sizeof(oc->title));
3338
        if (str_author)
3339
            av_strlcpy(oc->author, str_author, sizeof(oc->author));
3340
        if (str_copyright)
3341
            av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3342
        if (str_comment)
3343
            av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3344
        if (str_album)
3345
            av_strlcpy(oc->album, str_album, sizeof(oc->album));
3346
        if (str_genre)
3347
            av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3348
    }
3349

    
3350
    output_files[nb_output_files++] = oc;
3351

    
3352
    /* check filename in case of an image number is expected */
3353
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3354
        if (!av_filename_number_test(oc->filename)) {
3355
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3356
            av_exit(1);
3357
        }
3358
    }
3359

    
3360
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3361
        /* test if it already exists to avoid loosing precious files */
3362
        if (!file_overwrite &&
3363
            (strchr(filename, ':') == NULL ||
3364
             filename[1] == ':' ||
3365
             av_strstart(filename, "file:", NULL))) {
3366
            if (url_exist(filename)) {
3367
                int c;
3368

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

    
3385
        /* open the file */
3386
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3387
            fprintf(stderr, "Could not open '%s'\n", filename);
3388
            av_exit(1);
3389
        }
3390
    }
3391

    
3392
    memset(ap, 0, sizeof(*ap));
3393
    if (av_set_parameters(oc, ap) < 0) {
3394
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3395
                oc->filename);
3396
        av_exit(1);
3397
    }
3398

    
3399
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3400
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3401
    oc->loop_output = loop_output;
3402

    
3403
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3404

    
3405
    /* reset some options */
3406
    file_oformat = NULL;
3407
    file_iformat = NULL;
3408
}
3409

    
3410
/* same option as mencoder */
3411
static void opt_pass(const char *pass_str)
3412
{
3413
    int pass;
3414
    pass = atoi(pass_str);
3415
    if (pass != 1 && pass != 2) {
3416
        fprintf(stderr, "pass number can be only 1 or 2\n");
3417
        av_exit(1);
3418
    }
3419
    do_pass = pass;
3420
}
3421

    
3422
static int64_t getutime(void)
3423
{
3424
#if HAVE_GETRUSAGE
3425
    struct rusage rusage;
3426

    
3427
    getrusage(RUSAGE_SELF, &rusage);
3428
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3429
#elif HAVE_GETPROCESSTIMES
3430
    HANDLE proc;
3431
    FILETIME c, e, k, u;
3432
    proc = GetCurrentProcess();
3433
    GetProcessTimes(proc, &c, &e, &k, &u);
3434
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3435
#else
3436
    return av_gettime();
3437
#endif
3438
}
3439

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

    
3457
static void opt_inter_matrix(const char *arg)
3458
{
3459
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3460
    parse_matrix_coeffs(inter_matrix, arg);
3461
}
3462

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

    
3469
/**
3470
 * Trivial log callback.
3471
 * Only suitable for show_help and similar since it lacks prefix handling.
3472
 */
3473
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3474
{
3475
    vfprintf(stdout, fmt, vl);
3476
}
3477

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

    
3515
static void opt_target(const char *arg)
3516
{
3517
    int norm = -1;
3518
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3519

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

    
3564
    if(norm < 0) {
3565
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3566
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3567
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3568
        av_exit(1);
3569
    }
3570

    
3571
    if(!strcmp(arg, "vcd")) {
3572

    
3573
        opt_video_codec("mpeg1video");
3574
        opt_audio_codec("mp2");
3575
        opt_format("vcd");
3576

    
3577
        opt_frame_size(norm ? "352x240" : "352x288");
3578
        opt_frame_rate(NULL, frame_rates[norm]);
3579
        opt_default("gop", norm ? "18" : "15");
3580

    
3581
        opt_default("b", "1150000");
3582
        opt_default("maxrate", "1150000");
3583
        opt_default("minrate", "1150000");
3584
        opt_default("bufsize", "327680"); // 40*1024*8;
3585

    
3586
        opt_default("ab", "224000");
3587
        audio_sample_rate = 44100;
3588
        audio_channels = 2;
3589

    
3590
        opt_default("packetsize", "2324");
3591
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3592

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

    
3601
        opt_video_codec("mpeg2video");
3602
        opt_audio_codec("mp2");
3603
        opt_format("svcd");
3604

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

    
3609
        opt_default("b", "2040000");
3610
        opt_default("maxrate", "2516000");
3611
        opt_default("minrate", "0"); //1145000;
3612
        opt_default("bufsize", "1835008"); //224*1024*8;
3613
        opt_default("flags", "+scan_offset");
3614

    
3615

    
3616
        opt_default("ab", "224000");
3617
        audio_sample_rate = 44100;
3618

    
3619
        opt_default("packetsize", "2324");
3620

    
3621
    } else if(!strcmp(arg, "dvd")) {
3622

    
3623
        opt_video_codec("mpeg2video");
3624
        opt_audio_codec("ac3");
3625
        opt_format("dvd");
3626

    
3627
        opt_frame_size(norm ? "720x480" : "720x576");
3628
        opt_frame_rate(NULL, frame_rates[norm]);
3629
        opt_default("gop", norm ? "18" : "15");
3630

    
3631
        opt_default("b", "6000000");
3632
        opt_default("maxrate", "9000000");
3633
        opt_default("minrate", "0"); //1500000;
3634
        opt_default("bufsize", "1835008"); //224*1024*8;
3635

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

    
3639
        opt_default("ab", "448000");
3640
        audio_sample_rate = 48000;
3641

    
3642
    } else if(!strncmp(arg, "dv", 2)) {
3643

    
3644
        opt_format("dv");
3645

    
3646
        opt_frame_size(norm ? "720x480" : "720x576");
3647
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3648
                                             (norm ? "yuv411p" : "yuv420p"));
3649
        opt_frame_rate(NULL, frame_rates[norm]);
3650

    
3651
        audio_sample_rate = 48000;
3652
        audio_channels = 2;
3653

    
3654
    } else {
3655
        fprintf(stderr, "Unknown target: %s\n", arg);
3656
        av_exit(1);
3657
    }
3658
}
3659

    
3660
static void opt_vstats_file (const char *arg)
3661
{
3662
    av_free (vstats_filename);
3663
    vstats_filename=av_strdup (arg);
3664
}
3665

    
3666
static void opt_vstats (void)
3667
{
3668
    char filename[40];
3669
    time_t today2 = time(NULL);
3670
    struct tm *today = localtime(&today2);
3671

    
3672
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3673
             today->tm_sec);
3674
    opt_vstats_file(filename);
3675
}
3676

    
3677
static int opt_bsf(const char *opt, const char *arg)
3678
{
3679
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3680
    AVBitStreamFilterContext **bsfp;
3681

    
3682
    if(!bsfc){
3683
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3684
        av_exit(1);
3685
    }
3686

    
3687
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3688
          *opt == 'a' ? &audio_bitstream_filters :
3689
                        &subtitle_bitstream_filters;
3690
    while(*bsfp)
3691
        bsfp= &(*bsfp)->next;
3692

    
3693
    *bsfp= bsfc;
3694

    
3695
    return 0;
3696
}
3697

    
3698
static int opt_preset(const char *opt, const char *arg)
3699
{
3700
    FILE *f=NULL;
3701
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3702
    int i;
3703
    const char *base[2]= { getenv("HOME"),
3704
                           FFMPEG_DATADIR,
3705
                         };
3706

    
3707
    for(i=!base[0]; i<2 && !f; i++){
3708
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3709
        f= fopen(filename, "r");
3710
        if(!f){
3711
            char *codec_name= *opt == 'v' ? video_codec_name :
3712
                              *opt == 'a' ? audio_codec_name :
3713
                                            subtitle_codec_name;
3714
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3715
            f= fopen(filename, "r");
3716
        }
3717
    }
3718
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3719
              is_dos_path(arg))){
3720
        snprintf(filename, sizeof(filename), arg);
3721
        f= fopen(filename, "r");
3722
    }
3723

    
3724
    if(!f){
3725
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3726
        av_exit(1);
3727
    }
3728

    
3729
    while(!feof(f)){
3730
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3731
        if(line[0] == '#' && !e)
3732
            continue;
3733
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3734
        if(e){
3735
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3736
            av_exit(1);
3737
        }
3738
        if(!strcmp(tmp, "acodec")){
3739
            opt_audio_codec(tmp2);
3740
        }else if(!strcmp(tmp, "vcodec")){
3741
            opt_video_codec(tmp2);
3742
        }else if(!strcmp(tmp, "scodec")){
3743
            opt_subtitle_codec(tmp2);
3744
        }else if(opt_default(tmp, tmp2) < 0){
3745
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3746
            av_exit(1);
3747
        }
3748
    }
3749

    
3750
    fclose(f);
3751

    
3752
    return 0;
3753
}
3754

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

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

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

    
3861
    /* subtitle options */
3862
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3863
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3864
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3865
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3866

    
3867
    /* grab options */
3868
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3869
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3870
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3871

    
3872
    /* muxer options */
3873
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3874
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3875

    
3876
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3877
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3878
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3879

    
3880
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3881
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3882
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3883

    
3884
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3885
    { NULL, },
3886
};
3887

    
3888
int main(int argc, char **argv)
3889
{
3890
    int i;
3891
    int64_t ti;
3892

    
3893
    avcodec_register_all();
3894
    avdevice_register_all();
3895
    av_register_all();
3896

    
3897
    if(isatty(STDIN_FILENO))
3898
        url_set_interrupt_cb(decode_interrupt_cb);
3899

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

    
3906
    show_banner();
3907

    
3908
    /* parse options */
3909
    parse_options(argc, argv, options, opt_output_file);
3910

    
3911
    /* file converter / grab */
3912
    if (nb_output_files <= 0) {
3913
        fprintf(stderr, "At least one output file must be specified\n");
3914
        av_exit(1);
3915
    }
3916

    
3917
    if (nb_input_files == 0) {
3918
        fprintf(stderr, "At least one input file must be specified\n");
3919
        av_exit(1);
3920
    }
3921

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

    
3931
    return av_exit(0);
3932
}