Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 031e14ea

History | View | Annotate | Download (140 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 "libavcodec/opt.h"
38
#include "libavcodec/audioconvert.h"
39
#include "libavutil/fifo.h"
40
#include "libavutil/avstring.h"
41
#include "libavformat/os_support.h"
42

    
43
#if HAVE_SYS_RESOURCE_H
44
#include <sys/types.h>
45
#include <sys/resource.h>
46
#elif HAVE_GETPROCESSTIMES
47
#include <windows.h>
48
#endif
49

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

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

    
65
#include "cmdutils.h"
66

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

    
70
#undef exit
71

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

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

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

    
89
static const OptionDef options[];
90

    
91
#define MAX_FILES 20
92

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

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

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

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

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

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

    
162
static int subtitle_disable = 0;
163
static char *subtitle_codec_name = NULL;
164
static char *subtitle_language = NULL;
165
static int subtitle_codec_tag = 0;
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 int metadata_count;
176
static AVMetadataTag *metadata;
177
static int do_benchmark = 0;
178
static int do_hex_dump = 0;
179
static int do_pkt_dump = 0;
180
static int do_psnr = 0;
181
static int do_pass = 0;
182
static char *pass_logfilename_prefix = NULL;
183
static int audio_stream_copy = 0;
184
static int video_stream_copy = 0;
185
static int subtitle_stream_copy = 0;
186
static int video_sync_method= -1;
187
static int audio_sync_method= 0;
188
static float audio_drift_threshold= 0.1;
189
static int copy_ts= 0;
190
static int opt_shortest = 0;
191
static int video_global_header = 0;
192
static char *vstats_filename;
193
static FILE *vstats_file;
194
static int opt_programid = 0;
195
static int copy_initial_nonkeyframes = 0;
196

    
197
static int rate_emu = 0;
198

    
199
static int  video_channel = 0;
200
static char *video_standard;
201

    
202
static int audio_volume = 256;
203

    
204
static int exit_on_error = 0;
205
static int using_stdin = 0;
206
static int verbose = 1;
207
static int thread_count= 1;
208
static int q_pressed = 0;
209
static int64_t video_size = 0;
210
static int64_t audio_size = 0;
211
static int64_t extra_size = 0;
212
static int nb_frames_dup = 0;
213
static int nb_frames_drop = 0;
214
static int input_sync;
215
static uint64_t limit_filesize = 0;
216
static int force_fps = 0;
217

    
218
static int pgmyuv_compatibility_hack=0;
219
static float dts_delta_threshold = 10;
220

    
221
static unsigned int sws_flags = SWS_BICUBIC;
222

    
223
static int64_t timer_start;
224

    
225
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
226
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
227
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
228
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
229

    
230
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
231

    
232
struct AVInputStream;
233

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

    
252
    int video_crop;
253
    int topBand;             /* cropping area sizes */
254
    int leftBand;
255

    
256
    int video_pad;
257
    int padtop;              /* padding area sizes */
258
    int padbottom;
259
    int padleft;
260
    int padright;
261

    
262
    /* audio only */
263
    int audio_resample;
264
    ReSampleContext *resample; /* for audio resampling */
265
    int reformat_pair;
266
    AVAudioConvert *reformat_ctx;
267
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
268
    FILE *logfile;
269
} AVOutputStream;
270

    
271
typedef struct AVInputStream {
272
    int file_index;
273
    int index;
274
    AVStream *st;
275
    int discard;             /* true if stream data should be discarded */
276
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
277
    int64_t sample_index;      /* current sample */
278

    
279
    int64_t       start;     /* time when read started */
280
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
281
                                is not defined */
282
    int64_t       pts;       /* current pts */
283
    int is_start;            /* is 1 at the start and after a discontinuity */
284
} AVInputStream;
285

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

    
293
#if HAVE_TERMIOS_H
294

    
295
/* init terminal so that we can grab keys */
296
static struct termios oldtty;
297
#endif
298

    
299
static void term_exit(void)
300
{
301
#if HAVE_TERMIOS_H
302
    tcsetattr (0, TCSANOW, &oldtty);
303
#endif
304
}
305

    
306
static volatile sig_atomic_t received_sigterm = 0;
307

    
308
static void
309
sigterm_handler(int sig)
310
{
311
    received_sigterm = sig;
312
    term_exit();
313
}
314

    
315
static void term_init(void)
316
{
317
#if HAVE_TERMIOS_H
318
    struct termios tty;
319

    
320
    tcgetattr (0, &tty);
321
    oldtty = tty;
322

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

    
332
    tcsetattr (0, TCSANOW, &tty);
333
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
334
#endif
335

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

    
347
/* read a key without blocking */
348
static int read_key(void)
349
{
350
#if HAVE_TERMIOS_H
351
    int n = 1;
352
    unsigned char ch;
353
#if !CONFIG_BEOS_NETSERVER
354
    struct timeval tv;
355
    fd_set rfds;
356

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

    
368
        return n;
369
    }
370
#elif HAVE_CONIO_H
371
    if(kbhit())
372
        return(getch());
373
#endif
374
    return -1;
375
}
376

    
377
static int decode_interrupt_cb(void)
378
{
379
    return q_pressed || (q_pressed = read_key() == 'q');
380
}
381

    
382
static int av_exit(int ret)
383
{
384
    int i;
385

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

    
410
    av_free(intra_matrix);
411
    av_free(inter_matrix);
412

    
413
    if (vstats_file)
414
        fclose(vstats_file);
415
    av_free(vstats_filename);
416

    
417
    av_free(opt_names);
418

    
419
    av_free(video_codec_name);
420
    av_free(audio_codec_name);
421
    av_free(subtitle_codec_name);
422

    
423
    av_free(video_standard);
424

    
425
#if CONFIG_POWERPC_PERF
426
    void powerpc_display_perf_report(void);
427
    powerpc_display_perf_report();
428
#endif /* CONFIG_POWERPC_PERF */
429

    
430
    if (received_sigterm) {
431
        fprintf(stderr,
432
            "Received signal %d: terminating.\n",
433
            (int) received_sigterm);
434
        exit (255);
435
    }
436

    
437
    exit(ret); /* not all OS-es handle main() return value */
438
    return ret;
439
}
440

    
441
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
442
{
443
    int i, err;
444
    AVFormatContext *ic;
445
    int nopts = 0;
446

    
447
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
448
    if (err < 0)
449
        return err;
450
    /* copy stream format */
451
    s->nb_streams = ic->nb_streams;
452
    for(i=0;i<ic->nb_streams;i++) {
453
        AVStream *st;
454

    
455
        // FIXME: a more elegant solution is needed
456
        st = av_mallocz(sizeof(AVStream));
457
        memcpy(st, ic->streams[i], sizeof(AVStream));
458
        st->codec = avcodec_alloc_context();
459
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
460
        s->streams[i] = st;
461

    
462
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
463
            st->stream_copy = 1;
464
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
465
            st->stream_copy = 1;
466

    
467
        if(!st->codec->thread_count)
468
            st->codec->thread_count = 1;
469
        if(st->codec->thread_count>1)
470
            avcodec_thread_init(st->codec, st->codec->thread_count);
471

    
472
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
473
            nopts = 1;
474
    }
475

    
476
    if (!nopts)
477
        s->timestamp = av_gettime();
478

    
479
    av_close_input_file(ic);
480
    return 0;
481
}
482

    
483
static double
484
get_sync_ipts(const AVOutputStream *ost)
485
{
486
    const AVInputStream *ist = ost->sync_ist;
487
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
488
}
489

    
490
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
491
    int ret;
492

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

    
512
        bsfc= bsfc->next;
513
    }
514

    
515
    ret= av_interleaved_write_frame(s, pkt);
516
    if(ret < 0){
517
        print_error("av_interleaved_write_frame()", ret);
518
        av_exit(1);
519
    }
520
}
521

    
522
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
523

    
524
static void do_audio_out(AVFormatContext *s,
525
                         AVOutputStream *ost,
526
                         AVInputStream *ist,
527
                         unsigned char *buf, int size)
528
{
529
    uint8_t *buftmp;
530
    static uint8_t *audio_buf = NULL;
531
    static uint8_t *audio_out = NULL;
532
    static uint8_t *audio_out2 = NULL;
533
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
534

    
535
    int size_out, frame_bytes, ret;
536
    AVCodecContext *enc= ost->st->codec;
537
    AVCodecContext *dec= ist->st->codec;
538
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
539
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
540

    
541
    /* SC: dynamic allocation of buffers */
542
    if (!audio_buf)
543
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
544
    if (!audio_out)
545
        audio_out = av_malloc(audio_out_size);
546
    if (!audio_buf || !audio_out)
547
        return;               /* Should signal an error ! */
548

    
549
    if (enc->channels != dec->channels)
550
        ost->audio_resample = 1;
551

    
552
    if (ost->audio_resample && !ost->resample) {
553
        if (dec->sample_fmt != SAMPLE_FMT_S16)
554
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
555
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
556
                                               enc->sample_rate, dec->sample_rate,
557
                                               enc->sample_fmt,  dec->sample_fmt,
558
                                               16, 10, 0, 0.8);
559
        if (!ost->resample) {
560
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
561
                    dec->channels, dec->sample_rate,
562
                    enc->channels, enc->sample_rate);
563
            av_exit(1);
564
        }
565
    }
566

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

    
587
    if(audio_sync_method){
588
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
589
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
590
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
591
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
592

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

    
609
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
610
                        ist->is_start=0;
611
                    else
612
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
613

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

    
634
    if (ost->audio_resample) {
635
        buftmp = audio_buf;
636
        size_out = audio_resample(ost->resample,
637
                                  (short *)buftmp, (short *)buf,
638
                                  size / (ist->st->codec->channels * isize));
639
        size_out = size_out * enc->channels * osize;
640
    } else {
641
        buftmp = buf;
642
        size_out = size;
643
    }
644

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

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

    
670
        frame_bytes = enc->frame_size * osize * enc->channels;
671

    
672
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
673
            AVPacket pkt;
674
            av_init_packet(&pkt);
675

    
676
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
677

    
678
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
679

    
680
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
681
                                       (short *)audio_buf);
682
            if (ret < 0) {
683
                fprintf(stderr, "Audio encoding failed\n");
684
                av_exit(1);
685
            }
686
            audio_size += ret;
687
            pkt.stream_index= ost->index;
688
            pkt.data= audio_out;
689
            pkt.size= ret;
690
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
691
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
692
            pkt.flags |= PKT_FLAG_KEY;
693
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
694

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

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

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

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

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

    
735
    dec = ist->st->codec;
736

    
737
    /* deinterlace : must be done before any resize */
738
    if (do_deinterlace) {
739
        int size;
740

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

    
747
        picture2 = &picture_tmp;
748
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
749

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
851
    *frame_size = 0;
852

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1073

    
1074
    oc = output_files[0];
1075

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

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

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

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

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

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

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

    
1155
        fflush(stderr);
1156
    }
1157

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

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

    
1188
    if(ist->next_pts == AV_NOPTS_VALUE)
1189
        ist->next_pts= ist->pts;
1190

    
1191
    if (pkt == NULL) {
1192
        /* EOF handling */
1193
        av_init_packet(&avpkt);
1194
        avpkt.data = NULL;
1195
        avpkt.size = 0;
1196
        goto handle_eof;
1197
    } else {
1198
        avpkt = *pkt;
1199
    }
1200

    
1201
    if(pkt->dts != AV_NOPTS_VALUE)
1202
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1203

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

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

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

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

    
1300
        buffer_to_free = NULL;
1301
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1302
            pre_process_video_frame(ist, (AVPicture *)&picture,
1303
                                    &buffer_to_free);
1304
        }
1305

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

    
1320
        /* frame rate emulation */
1321
        if (rate_emu) {
1322
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1323
            int64_t now = av_gettime() - ist->start;
1324
            if (pts > now)
1325
                usleep(pts - now);
1326
        }
1327

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

    
1334
                ost = ost_table[i];
1335
                if (ost->source_index == ist_index) {
1336
                    os = output_files[ost->file_index];
1337

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

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

    
1369
                        av_init_packet(&opkt);
1370

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

    
1374
                        /* no reencoding needed : output the packet directly */
1375
                        /* force the input stream PTS */
1376

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1540
    return -1;
1541
}
1542

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1730
        codec = ost->st->codec;
1731
        icodec = ist->st->codec;
1732

    
1733
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1734
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1735
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1736

    
1737
        ost->st->disposition = ist->st->disposition;
1738

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

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

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

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

    
1905
    if (!bit_buffer)
1906
        bit_buffer = av_malloc(bit_buffer_size);
1907
    if (!bit_buffer) {
1908
        ret = AVERROR(ENOMEM);
1909
        goto fail;
1910
    }
1911

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

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

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

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

    
1974
        int out_file_index = meta_data_maps[i].out_file;
1975
        int in_file_index = meta_data_maps[i].in_file;
1976
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1977
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
1978
                     out_file_index, out_file_index, in_file_index);
1979
            ret = AVERROR(EINVAL);
1980
            goto dump_format;
1981
        }
1982
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1983
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
1984
                     in_file_index, out_file_index, in_file_index);
1985
            ret = AVERROR(EINVAL);
1986
            goto dump_format;
1987
        }
1988

    
1989
        out_file = output_files[out_file_index];
1990
        in_file = input_files[in_file_index];
1991

    
1992

    
1993
        mtag=NULL;
1994
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
1995
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
1996
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
1997
                                    in_file->iformat->metadata_conv);
1998
    }
1999

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

    
2013
 dump_format:
2014
    /* dump the file output parameters - cannot be done before in case
2015
       of stream copy */
2016
    for(i=0;i<nb_output_files;i++) {
2017
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2018
    }
2019

    
2020
    /* dump the stream mapping */
2021
    if (verbose >= 0) {
2022
        fprintf(stderr, "Stream mapping:\n");
2023
        for(i=0;i<nb_ostreams;i++) {
2024
            ost = ost_table[i];
2025
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2026
                    ist_table[ost->source_index]->file_index,
2027
                    ist_table[ost->source_index]->index,
2028
                    ost->file_index,
2029
                    ost->index);
2030
            if (ost->sync_ist != ist_table[ost->source_index])
2031
                fprintf(stderr, " [sync #%d.%d]",
2032
                        ost->sync_ist->file_index,
2033
                        ost->sync_ist->index);
2034
            fprintf(stderr, "\n");
2035
        }
2036
    }
2037

    
2038
    if (ret) {
2039
        fprintf(stderr, "%s\n", error);
2040
        goto fail;
2041
    }
2042

    
2043
    if (want_sdp) {
2044
        print_sdp(output_files, nb_output_files);
2045
    }
2046

    
2047
    if (!using_stdin && verbose >= 0) {
2048
        fprintf(stderr, "Press [q] to stop encoding\n");
2049
        url_set_interrupt_cb(decode_interrupt_cb);
2050
    }
2051
    term_init();
2052

    
2053
    key = -1;
2054
    timer_start = av_gettime();
2055

    
2056
    for(; received_sigterm == 0;) {
2057
        int file_index, ist_index;
2058
        AVPacket pkt;
2059
        double ipts_min;
2060
        double opts_min;
2061

    
2062
    redo:
2063
        ipts_min= 1e100;
2064
        opts_min= 1e100;
2065
        /* if 'q' pressed, exits */
2066
        if (!using_stdin) {
2067
            if (q_pressed)
2068
                break;
2069
            /* read_key() returns 0 on EOF */
2070
            key = read_key();
2071
            if (key == 'q')
2072
                break;
2073
        }
2074

    
2075
        /* select the stream that we must read now by looking at the
2076
           smallest output pts */
2077
        file_index = -1;
2078
        for(i=0;i<nb_ostreams;i++) {
2079
            double ipts, opts;
2080
            ost = ost_table[i];
2081
            os = output_files[ost->file_index];
2082
            ist = ist_table[ost->source_index];
2083
            if(no_packet[ist->file_index])
2084
                continue;
2085
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2086
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2087
            else
2088
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2089
            ipts = (double)ist->pts;
2090
            if (!file_table[ist->file_index].eof_reached){
2091
                if(ipts < ipts_min) {
2092
                    ipts_min = ipts;
2093
                    if(input_sync ) file_index = ist->file_index;
2094
                }
2095
                if(opts < opts_min) {
2096
                    opts_min = opts;
2097
                    if(!input_sync) file_index = ist->file_index;
2098
                }
2099
            }
2100
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2101
                file_index= -1;
2102
                break;
2103
            }
2104
        }
2105
        /* if none, if is finished */
2106
        if (file_index < 0) {
2107
            if(no_packet_count){
2108
                no_packet_count=0;
2109
                memset(no_packet, 0, sizeof(no_packet));
2110
                usleep(10000);
2111
                continue;
2112
            }
2113
            break;
2114
        }
2115

    
2116
        /* finish if recording time exhausted */
2117
        if (opts_min >= (recording_time / 1000000.0))
2118
            break;
2119

    
2120
        /* finish if limit size exhausted */
2121
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2122
            break;
2123

    
2124
        /* read a frame from it and output it in the fifo */
2125
        is = input_files[file_index];
2126
        ret= av_read_frame(is, &pkt);
2127
        if(ret == AVERROR(EAGAIN)){
2128
            no_packet[file_index]=1;
2129
            no_packet_count++;
2130
            continue;
2131
        }
2132
        if (ret < 0) {
2133
            file_table[file_index].eof_reached = 1;
2134
            if (opt_shortest)
2135
                break;
2136
            else
2137
                continue;
2138
        }
2139

    
2140
        no_packet_count=0;
2141
        memset(no_packet, 0, sizeof(no_packet));
2142

    
2143
        if (do_pkt_dump) {
2144
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2145
        }
2146
        /* the following test is needed in case new streams appear
2147
           dynamically in stream : we ignore them */
2148
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2149
            goto discard_packet;
2150
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2151
        ist = ist_table[ist_index];
2152
        if (ist->discard)
2153
            goto discard_packet;
2154

    
2155
        if (pkt.dts != AV_NOPTS_VALUE)
2156
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2157
        if (pkt.pts != AV_NOPTS_VALUE)
2158
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2159

    
2160
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2161
            if(pkt.pts != AV_NOPTS_VALUE)
2162
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2163
            if(pkt.dts != AV_NOPTS_VALUE)
2164
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2165
        }
2166

    
2167
//        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);
2168
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2169
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2170
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2171
            int64_t delta= pkt_dts - ist->next_pts;
2172
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2173
                input_files_ts_offset[ist->file_index]-= delta;
2174
                if (verbose > 2)
2175
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2176
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2177
                if(pkt.pts != AV_NOPTS_VALUE)
2178
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2179
            }
2180
        }
2181

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

    
2185
            if (verbose >= 0)
2186
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2187
                        ist->file_index, ist->index);
2188
            if (exit_on_error)
2189
                av_exit(1);
2190
            av_free_packet(&pkt);
2191
            goto redo;
2192
        }
2193

    
2194
    discard_packet:
2195
        av_free_packet(&pkt);
2196

    
2197
        /* dump report by using the output first video and audio streams */
2198
        print_report(output_files, ost_table, nb_ostreams, 0);
2199
    }
2200

    
2201
    /* at the end of stream, we must flush the decoder buffers */
2202
    for(i=0;i<nb_istreams;i++) {
2203
        ist = ist_table[i];
2204
        if (ist->decoding_needed) {
2205
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2206
        }
2207
    }
2208

    
2209
    term_exit();
2210

    
2211
    /* write the trailer if needed and close file */
2212
    for(i=0;i<nb_output_files;i++) {
2213
        os = output_files[i];
2214
        av_write_trailer(os);
2215
    }
2216

    
2217
    /* dump report by using the first video and audio streams */
2218
    print_report(output_files, ost_table, nb_ostreams, 1);
2219

    
2220
    /* close each encoder */
2221
    for(i=0;i<nb_ostreams;i++) {
2222
        ost = ost_table[i];
2223
        if (ost->encoding_needed) {
2224
            av_freep(&ost->st->codec->stats_in);
2225
            avcodec_close(ost->st->codec);
2226
        }
2227
    }
2228

    
2229
    /* close each decoder */
2230
    for(i=0;i<nb_istreams;i++) {
2231
        ist = ist_table[i];
2232
        if (ist->decoding_needed) {
2233
            avcodec_close(ist->st->codec);
2234
        }
2235
    }
2236

    
2237
    /* finished ! */
2238
    ret = 0;
2239

    
2240
 fail:
2241
    av_freep(&bit_buffer);
2242
    av_free(file_table);
2243

    
2244
    if (ist_table) {
2245
        for(i=0;i<nb_istreams;i++) {
2246
            ist = ist_table[i];
2247
            av_free(ist);
2248
        }
2249
        av_free(ist_table);
2250
    }
2251
    if (ost_table) {
2252
        for(i=0;i<nb_ostreams;i++) {
2253
            ost = ost_table[i];
2254
            if (ost) {
2255
                if (ost->logfile) {
2256
                    fclose(ost->logfile);
2257
                    ost->logfile = NULL;
2258
                }
2259
                av_fifo_free(ost->fifo); /* works even if fifo is not
2260
                                             initialized but set to zero */
2261
                av_free(ost->pict_tmp.data[0]);
2262
                if (ost->video_resample)
2263
                    sws_freeContext(ost->img_resample_ctx);
2264
                if (ost->resample)
2265
                    audio_resample_close(ost->resample);
2266
                if (ost->reformat_ctx)
2267
                    av_audio_convert_free(ost->reformat_ctx);
2268
                av_free(ost);
2269
            }
2270
        }
2271
        av_free(ost_table);
2272
    }
2273
    return ret;
2274
}
2275

    
2276
#if 0
2277
int file_read(const char *filename)
2278
{
2279
    URLContext *h;
2280
    unsigned char buffer[1024];
2281
    int len, i;
2282

2283
    if (url_open(&h, filename, O_RDONLY) < 0) {
2284
        printf("could not open '%s'\n", filename);
2285
        return -1;
2286
    }
2287
    for(;;) {
2288
        len = url_read(h, buffer, sizeof(buffer));
2289
        if (len <= 0)
2290
            break;
2291
        for(i=0;i<len;i++) putchar(buffer[i]);
2292
    }
2293
    url_close(h);
2294
    return 0;
2295
}
2296
#endif
2297

    
2298
static void opt_format(const char *arg)
2299
{
2300
    /* compatibility stuff for pgmyuv */
2301
    if (!strcmp(arg, "pgmyuv")) {
2302
        pgmyuv_compatibility_hack=1;
2303
//        opt_image_format(arg);
2304
        arg = "image2";
2305
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2306
    }
2307

    
2308
    file_iformat = av_find_input_format(arg);
2309
    file_oformat = guess_format(arg, NULL, NULL);
2310
    if (!file_iformat && !file_oformat) {
2311
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2312
        av_exit(1);
2313
    }
2314
}
2315

    
2316
static void opt_video_rc_override_string(const char *arg)
2317
{
2318
    video_rc_override_string = arg;
2319
}
2320

    
2321
static int opt_me_threshold(const char *opt, const char *arg)
2322
{
2323
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2324
    return 0;
2325
}
2326

    
2327
static void opt_loglevel(const char *opt, const char *arg)
2328
{
2329
    int level = parse_number_or_die(opt, arg, OPT_INT, INT_MIN, INT_MAX);
2330
    av_log_set_level(level);
2331
}
2332

    
2333
static int opt_verbose(const char *opt, const char *arg)
2334
{
2335
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2336
    return 0;
2337
}
2338

    
2339
static int opt_frame_rate(const char *opt, const char *arg)
2340
{
2341
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2342
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2343
        av_exit(1);
2344
    }
2345
    return 0;
2346
}
2347

    
2348
static int opt_bitrate(const char *opt, const char *arg)
2349
{
2350
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2351

    
2352
    opt_default(opt, arg);
2353

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

    
2357
    return 0;
2358
}
2359

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

    
2378
static void opt_frame_crop_bottom(const char *arg)
2379
{
2380
    frame_bottomBand = atoi(arg);
2381
    if (frame_bottomBand < 0) {
2382
        fprintf(stderr, "Incorrect bottom crop size\n");
2383
        av_exit(1);
2384
    }
2385
    if ((frame_bottomBand % 2) != 0) {
2386
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2387
        av_exit(1);
2388
    }
2389
    if ((frame_bottomBand) >= frame_height){
2390
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2391
        av_exit(1);
2392
    }
2393
    frame_height -= frame_bottomBand;
2394
}
2395

    
2396
static void opt_frame_crop_left(const char *arg)
2397
{
2398
    frame_leftBand = atoi(arg);
2399
    if (frame_leftBand < 0) {
2400
        fprintf(stderr, "Incorrect left crop size\n");
2401
        av_exit(1);
2402
    }
2403
    if ((frame_leftBand % 2) != 0) {
2404
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2405
        av_exit(1);
2406
    }
2407
    if ((frame_leftBand) >= frame_width){
2408
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2409
        av_exit(1);
2410
    }
2411
    frame_width -= frame_leftBand;
2412
}
2413

    
2414
static void opt_frame_crop_right(const char *arg)
2415
{
2416
    frame_rightBand = atoi(arg);
2417
    if (frame_rightBand < 0) {
2418
        fprintf(stderr, "Incorrect right crop size\n");
2419
        av_exit(1);
2420
    }
2421
    if ((frame_rightBand % 2) != 0) {
2422
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2423
        av_exit(1);
2424
    }
2425
    if ((frame_rightBand) >= frame_width){
2426
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2427
        av_exit(1);
2428
    }
2429
    frame_width -= frame_rightBand;
2430
}
2431

    
2432
static void opt_frame_size(const char *arg)
2433
{
2434
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2435
        fprintf(stderr, "Incorrect frame size\n");
2436
        av_exit(1);
2437
    }
2438
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2439
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2440
        av_exit(1);
2441
    }
2442
}
2443

    
2444

    
2445
#define SCALEBITS 10
2446
#define ONE_HALF  (1 << (SCALEBITS - 1))
2447
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2448

    
2449
#define RGB_TO_Y(r, g, b) \
2450
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2451
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2452

    
2453
#define RGB_TO_U(r1, g1, b1, shift)\
2454
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2455
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2456

    
2457
#define RGB_TO_V(r1, g1, b1, shift)\
2458
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2459
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2460

    
2461
static void opt_pad_color(const char *arg) {
2462
    /* Input is expected to be six hex digits similar to
2463
       how colors are expressed in html tags (but without the #) */
2464
    int rgb = strtol(arg, NULL, 16);
2465
    int r,g,b;
2466

    
2467
    r = (rgb >> 16);
2468
    g = ((rgb >> 8) & 255);
2469
    b = (rgb & 255);
2470

    
2471
    padcolor[0] = RGB_TO_Y(r,g,b);
2472
    padcolor[1] = RGB_TO_U(r,g,b,0);
2473
    padcolor[2] = RGB_TO_V(r,g,b,0);
2474
}
2475

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

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

    
2502

    
2503
static void opt_frame_pad_left(const char *arg)
2504
{
2505
    frame_padleft = atoi(arg);
2506
    if (frame_padleft < 0) {
2507
        fprintf(stderr, "Incorrect left pad size\n");
2508
        av_exit(1);
2509
    }
2510
    if ((frame_padleft % 2) != 0) {
2511
        fprintf(stderr, "Left pad size must be a multiple of 2\n");
2512
        av_exit(1);
2513
    }
2514
}
2515

    
2516

    
2517
static void opt_frame_pad_right(const char *arg)
2518
{
2519
    frame_padright = atoi(arg);
2520
    if (frame_padright < 0) {
2521
        fprintf(stderr, "Incorrect right pad size\n");
2522
        av_exit(1);
2523
    }
2524
    if ((frame_padright % 2) != 0) {
2525
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2526
        av_exit(1);
2527
    }
2528
}
2529

    
2530
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2531
{
2532
    int i;
2533
    char fmt_str[128];
2534
    for (i=-1; i < nb_fmts; i++) {
2535
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2536
        fprintf(stdout, "%s\n", fmt_str);
2537
    }
2538
}
2539

    
2540
static void opt_frame_pix_fmt(const char *arg)
2541
{
2542
    if (strcmp(arg, "list")) {
2543
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2544
        if (frame_pix_fmt == PIX_FMT_NONE) {
2545
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2546
            av_exit(1);
2547
        }
2548
    } else {
2549
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2550
        av_exit(0);
2551
    }
2552
}
2553

    
2554
static void opt_frame_aspect_ratio(const char *arg)
2555
{
2556
    int x = 0, y = 0;
2557
    double ar = 0;
2558
    const char *p;
2559
    char *end;
2560

    
2561
    p = strchr(arg, ':');
2562
    if (p) {
2563
        x = strtol(arg, &end, 10);
2564
        if (end == p)
2565
            y = strtol(end+1, &end, 10);
2566
        if (x > 0 && y > 0)
2567
            ar = (double)x / (double)y;
2568
    } else
2569
        ar = strtod(arg, NULL);
2570

    
2571
    if (!ar) {
2572
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2573
        av_exit(1);
2574
    }
2575
    frame_aspect_ratio = ar;
2576
}
2577

    
2578
static int opt_metadata(const char *opt, const char *arg)
2579
{
2580
    char *mid= strchr(arg, '=');
2581

    
2582
    if(!mid){
2583
        fprintf(stderr, "Missing =\n");
2584
        av_exit(1);
2585
    }
2586
    *mid++= 0;
2587

    
2588
    metadata_count++;
2589
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2590
    metadata[metadata_count-1].key  = av_strdup(arg);
2591
    metadata[metadata_count-1].value= av_strdup(mid);
2592

    
2593
    return 0;
2594
}
2595

    
2596
static void opt_qscale(const char *arg)
2597
{
2598
    video_qscale = atof(arg);
2599
    if (video_qscale <= 0 ||
2600
        video_qscale > 255) {
2601
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2602
        av_exit(1);
2603
    }
2604
}
2605

    
2606
static void opt_top_field_first(const char *arg)
2607
{
2608
    top_field_first= atoi(arg);
2609
}
2610

    
2611
static int opt_thread_count(const char *opt, const char *arg)
2612
{
2613
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2614
#if !HAVE_THREADS
2615
    if (verbose >= 0)
2616
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2617
#endif
2618
    return 0;
2619
}
2620

    
2621
static void opt_audio_sample_fmt(const char *arg)
2622
{
2623
    if (strcmp(arg, "list"))
2624
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2625
    else {
2626
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2627
        av_exit(0);
2628
    }
2629
}
2630

    
2631
static int opt_audio_rate(const char *opt, const char *arg)
2632
{
2633
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2634
    return 0;
2635
}
2636

    
2637
static int opt_audio_channels(const char *opt, const char *arg)
2638
{
2639
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2640
    return 0;
2641
}
2642

    
2643
static void opt_video_channel(const char *arg)
2644
{
2645
    video_channel = strtol(arg, NULL, 0);
2646
}
2647

    
2648
static void opt_video_standard(const char *arg)
2649
{
2650
    video_standard = av_strdup(arg);
2651
}
2652

    
2653
static void opt_codec(int *pstream_copy, char **pcodec_name,
2654
                      int codec_type, const char *arg)
2655
{
2656
    av_freep(pcodec_name);
2657
    if (!strcmp(arg, "copy")) {
2658
        *pstream_copy = 1;
2659
    } else {
2660
        *pcodec_name = av_strdup(arg);
2661
    }
2662
}
2663

    
2664
static void opt_audio_codec(const char *arg)
2665
{
2666
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2667
}
2668

    
2669
static void opt_audio_tag(const char *arg)
2670
{
2671
    char *tail;
2672
    audio_codec_tag= strtol(arg, &tail, 0);
2673

    
2674
    if(!tail || *tail)
2675
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2676
}
2677

    
2678
static void opt_video_tag(const char *arg)
2679
{
2680
    char *tail;
2681
    video_codec_tag= strtol(arg, &tail, 0);
2682

    
2683
    if(!tail || *tail)
2684
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2685
}
2686

    
2687
static void opt_video_codec(const char *arg)
2688
{
2689
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2690
}
2691

    
2692
static void opt_subtitle_codec(const char *arg)
2693
{
2694
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2695
}
2696

    
2697
static void opt_subtitle_tag(const char *arg)
2698
{
2699
    char *tail;
2700
    subtitle_codec_tag= strtol(arg, &tail, 0);
2701

    
2702
    if(!tail || *tail)
2703
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2704
}
2705

    
2706
static void opt_map(const char *arg)
2707
{
2708
    AVStreamMap *m;
2709
    char *p;
2710

    
2711
    m = &stream_maps[nb_stream_maps++];
2712

    
2713
    m->file_index = strtol(arg, &p, 0);
2714
    if (*p)
2715
        p++;
2716

    
2717
    m->stream_index = strtol(p, &p, 0);
2718
    if (*p) {
2719
        p++;
2720
        m->sync_file_index = strtol(p, &p, 0);
2721
        if (*p)
2722
            p++;
2723
        m->sync_stream_index = strtol(p, &p, 0);
2724
    } else {
2725
        m->sync_file_index = m->file_index;
2726
        m->sync_stream_index = m->stream_index;
2727
    }
2728
}
2729

    
2730
static void opt_map_meta_data(const char *arg)
2731
{
2732
    AVMetaDataMap *m;
2733
    char *p;
2734

    
2735
    m = &meta_data_maps[nb_meta_data_maps++];
2736

    
2737
    m->out_file = strtol(arg, &p, 0);
2738
    if (*p)
2739
        p++;
2740

    
2741
    m->in_file = strtol(p, &p, 0);
2742
}
2743

    
2744
static void opt_input_ts_scale(const char *arg)
2745
{
2746
    unsigned int stream;
2747
    double scale;
2748
    char *p;
2749

    
2750
    stream = strtol(arg, &p, 0);
2751
    if (*p)
2752
        p++;
2753
    scale= strtod(p, &p);
2754

    
2755
    if(stream >= MAX_STREAMS)
2756
        av_exit(1);
2757

    
2758
    input_files_ts_scale[nb_input_files][stream]= scale;
2759
}
2760

    
2761
static int opt_recording_time(const char *opt, const char *arg)
2762
{
2763
    recording_time = parse_time_or_die(opt, arg, 1);
2764
    return 0;
2765
}
2766

    
2767
static int opt_start_time(const char *opt, const char *arg)
2768
{
2769
    start_time = parse_time_or_die(opt, arg, 1);
2770
    return 0;
2771
}
2772

    
2773
static int opt_rec_timestamp(const char *opt, const char *arg)
2774
{
2775
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2776
    return 0;
2777
}
2778

    
2779
static int opt_input_ts_offset(const char *opt, const char *arg)
2780
{
2781
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2782
    return 0;
2783
}
2784

    
2785
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2786
{
2787
    const char *codec_string = encoder ? "encoder" : "decoder";
2788
    AVCodec *codec;
2789

    
2790
    if(!name)
2791
        return CODEC_ID_NONE;
2792
    codec = encoder ?
2793
        avcodec_find_encoder_by_name(name) :
2794
        avcodec_find_decoder_by_name(name);
2795
    if(!codec) {
2796
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2797
        av_exit(1);
2798
    }
2799
    if(codec->type != type) {
2800
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2801
        av_exit(1);
2802
    }
2803
    return codec->id;
2804
}
2805

    
2806
static void opt_input_file(const char *filename)
2807
{
2808
    AVFormatContext *ic;
2809
    AVFormatParameters params, *ap = &params;
2810
    int err, i, ret, rfps, rfps_base;
2811
    int64_t timestamp;
2812

    
2813
    if (!strcmp(filename, "-"))
2814
        filename = "pipe:";
2815

    
2816
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2817
                    !strcmp(filename, "/dev/stdin");
2818

    
2819
    /* get default parameters from command line */
2820
    ic = avformat_alloc_context();
2821

    
2822
    memset(ap, 0, sizeof(*ap));
2823
    ap->prealloced_context = 1;
2824
    ap->sample_rate = audio_sample_rate;
2825
    ap->channels = audio_channels;
2826
    ap->time_base.den = frame_rate.num;
2827
    ap->time_base.num = frame_rate.den;
2828
    ap->width = frame_width + frame_padleft + frame_padright;
2829
    ap->height = frame_height + frame_padtop + frame_padbottom;
2830
    ap->pix_fmt = frame_pix_fmt;
2831
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2832
    ap->channel = video_channel;
2833
    ap->standard = video_standard;
2834
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2835
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2836
    if(pgmyuv_compatibility_hack)
2837
        ap->video_codec_id= CODEC_ID_PGMYUV;
2838

    
2839
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2840

    
2841
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2842
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2843
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2844
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2845

    
2846
    /* open the input file with generic libav function */
2847
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2848
    if (err < 0) {
2849
        print_error(filename, err);
2850
        av_exit(1);
2851
    }
2852
    if(opt_programid) {
2853
        int i;
2854
        for(i=0; i<ic->nb_programs; i++)
2855
            if(ic->programs[i]->id != opt_programid)
2856
                ic->programs[i]->discard = AVDISCARD_ALL;
2857
    }
2858

    
2859
    ic->loop_input = loop_input;
2860

    
2861
    /* If not enough info to get the stream parameters, we decode the
2862
       first frames to get it. (used in mpeg case for example) */
2863
    ret = av_find_stream_info(ic);
2864
    if (ret < 0 && verbose >= 0) {
2865
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2866
        av_exit(1);
2867
    }
2868

    
2869
    timestamp = start_time;
2870
    /* add the stream start time */
2871
    if (ic->start_time != AV_NOPTS_VALUE)
2872
        timestamp += ic->start_time;
2873

    
2874
    /* if seeking requested, we execute it */
2875
    if (start_time != 0) {
2876
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2877
        if (ret < 0) {
2878
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2879
                    filename, (double)timestamp / AV_TIME_BASE);
2880
        }
2881
        /* reset seek info */
2882
        start_time = 0;
2883
    }
2884

    
2885
    /* update the current parameters so that they match the one of the input stream */
2886
    for(i=0;i<ic->nb_streams;i++) {
2887
        AVCodecContext *enc = ic->streams[i]->codec;
2888
        if(thread_count>1)
2889
            avcodec_thread_init(enc, thread_count);
2890
        enc->thread_count= thread_count;
2891
        switch(enc->codec_type) {
2892
        case CODEC_TYPE_AUDIO:
2893
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2894
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2895
            channel_layout = enc->channel_layout;
2896
            audio_channels = enc->channels;
2897
            audio_sample_rate = enc->sample_rate;
2898
            audio_sample_fmt = enc->sample_fmt;
2899
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2900
            if(audio_disable)
2901
                ic->streams[i]->discard= AVDISCARD_ALL;
2902
            break;
2903
        case CODEC_TYPE_VIDEO:
2904
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2905
            frame_height = enc->height;
2906
            frame_width = enc->width;
2907
            if(ic->streams[i]->sample_aspect_ratio.num)
2908
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2909
            else
2910
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2911
            frame_aspect_ratio *= (float) enc->width / enc->height;
2912
            frame_pix_fmt = enc->pix_fmt;
2913
            rfps      = ic->streams[i]->r_frame_rate.num;
2914
            rfps_base = ic->streams[i]->r_frame_rate.den;
2915
            if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2916
            if(me_threshold)
2917
                enc->debug |= FF_DEBUG_MV;
2918

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

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

    
2925
                    (float)rfps / rfps_base, rfps, rfps_base);
2926
            }
2927
            /* update the current frame rate to match the stream frame rate */
2928
            frame_rate.num = rfps;
2929
            frame_rate.den = rfps_base;
2930

    
2931
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2932
            if(video_disable)
2933
                ic->streams[i]->discard= AVDISCARD_ALL;
2934
            else if(video_discard)
2935
                ic->streams[i]->discard= video_discard;
2936
            break;
2937
        case CODEC_TYPE_DATA:
2938
            break;
2939
        case CODEC_TYPE_SUBTITLE:
2940
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2941
            if(subtitle_disable)
2942
                ic->streams[i]->discard = AVDISCARD_ALL;
2943
            break;
2944
        case CODEC_TYPE_ATTACHMENT:
2945
        case CODEC_TYPE_UNKNOWN:
2946
            nb_icodecs++;
2947
            break;
2948
        default:
2949
            abort();
2950
        }
2951
    }
2952

    
2953
    input_files[nb_input_files] = ic;
2954
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2955
    /* dump the file content */
2956
    if (verbose >= 0)
2957
        dump_format(ic, nb_input_files, filename, 0);
2958

    
2959
    nb_input_files++;
2960
    file_iformat = NULL;
2961
    file_oformat = NULL;
2962

    
2963
    video_channel = 0;
2964

    
2965
    av_freep(&video_codec_name);
2966
    av_freep(&audio_codec_name);
2967
    av_freep(&subtitle_codec_name);
2968
}
2969

    
2970
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2971
                                         int *has_subtitle_ptr)
2972
{
2973
    int has_video, has_audio, has_subtitle, i, j;
2974
    AVFormatContext *ic;
2975

    
2976
    has_video = 0;
2977
    has_audio = 0;
2978
    has_subtitle = 0;
2979
    for(j=0;j<nb_input_files;j++) {
2980
        ic = input_files[j];
2981
        for(i=0;i<ic->nb_streams;i++) {
2982
            AVCodecContext *enc = ic->streams[i]->codec;
2983
            switch(enc->codec_type) {
2984
            case CODEC_TYPE_AUDIO:
2985
                has_audio = 1;
2986
                break;
2987
            case CODEC_TYPE_VIDEO:
2988
                has_video = 1;
2989
                break;
2990
            case CODEC_TYPE_SUBTITLE:
2991
                has_subtitle = 1;
2992
                break;
2993
            case CODEC_TYPE_DATA:
2994
            case CODEC_TYPE_ATTACHMENT:
2995
            case CODEC_TYPE_UNKNOWN:
2996
                break;
2997
            default:
2998
                abort();
2999
            }
3000
        }
3001
    }
3002
    *has_video_ptr = has_video;
3003
    *has_audio_ptr = has_audio;
3004
    *has_subtitle_ptr = has_subtitle;
3005
}
3006

    
3007
static void new_video_stream(AVFormatContext *oc)
3008
{
3009
    AVStream *st;
3010
    AVCodecContext *video_enc;
3011
    int codec_id;
3012

    
3013
    st = av_new_stream(oc, oc->nb_streams);
3014
    if (!st) {
3015
        fprintf(stderr, "Could not alloc stream\n");
3016
        av_exit(1);
3017
    }
3018
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3019
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3020
    video_bitstream_filters= NULL;
3021

    
3022
    if(thread_count>1)
3023
        avcodec_thread_init(st->codec, thread_count);
3024

    
3025
    video_enc = st->codec;
3026

    
3027
    if(video_codec_tag)
3028
        video_enc->codec_tag= video_codec_tag;
3029

    
3030
    if(   (video_global_header&1)
3031
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3032
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3033
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3034
    }
3035
    if(video_global_header&2){
3036
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3037
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3038
    }
3039

    
3040
    if (video_stream_copy) {
3041
        st->stream_copy = 1;
3042
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3043
        video_enc->sample_aspect_ratio =
3044
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3045
    } else {
3046
        const char *p;
3047
        int i;
3048
        AVCodec *codec;
3049
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3050

    
3051
        if (video_codec_name) {
3052
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3053
            codec = avcodec_find_encoder_by_name(video_codec_name);
3054
            output_codecs[nb_ocodecs] = codec;
3055
        } else {
3056
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3057
            codec = avcodec_find_encoder(codec_id);
3058
        }
3059

    
3060
        video_enc->codec_id = codec_id;
3061

    
3062
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3063

    
3064
        if (codec && codec->supported_framerates && !force_fps)
3065
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3066
        video_enc->time_base.den = fps.num;
3067
        video_enc->time_base.num = fps.den;
3068

    
3069
        video_enc->width = frame_width + frame_padright + frame_padleft;
3070
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3071
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3072
        video_enc->pix_fmt = frame_pix_fmt;
3073
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3074

    
3075
        if(codec && codec->pix_fmts){
3076
            const enum PixelFormat *p= codec->pix_fmts;
3077
            for(; *p!=-1; p++){
3078
                if(*p == video_enc->pix_fmt)
3079
                    break;
3080
            }
3081
            if(*p == -1)
3082
                video_enc->pix_fmt = codec->pix_fmts[0];
3083
        }
3084

    
3085
        if (intra_only)
3086
            video_enc->gop_size = 0;
3087
        if (video_qscale || same_quality) {
3088
            video_enc->flags |= CODEC_FLAG_QSCALE;
3089
            video_enc->global_quality=
3090
                st->quality = FF_QP2LAMBDA * video_qscale;
3091
        }
3092

    
3093
        if(intra_matrix)
3094
            video_enc->intra_matrix = intra_matrix;
3095
        if(inter_matrix)
3096
            video_enc->inter_matrix = inter_matrix;
3097

    
3098
        video_enc->thread_count = thread_count;
3099
        p= video_rc_override_string;
3100
        for(i=0; p; i++){
3101
            int start, end, q;
3102
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3103
            if(e!=3){
3104
                fprintf(stderr, "error parsing rc_override\n");
3105
                av_exit(1);
3106
            }
3107
            video_enc->rc_override=
3108
                av_realloc(video_enc->rc_override,
3109
                           sizeof(RcOverride)*(i+1));
3110
            video_enc->rc_override[i].start_frame= start;
3111
            video_enc->rc_override[i].end_frame  = end;
3112
            if(q>0){
3113
                video_enc->rc_override[i].qscale= q;
3114
                video_enc->rc_override[i].quality_factor= 1.0;
3115
            }
3116
            else{
3117
                video_enc->rc_override[i].qscale= 0;
3118
                video_enc->rc_override[i].quality_factor= -q/100.0;
3119
            }
3120
            p= strchr(p, '/');
3121
            if(p) p++;
3122
        }
3123
        video_enc->rc_override_count=i;
3124
        if (!video_enc->rc_initial_buffer_occupancy)
3125
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3126
        video_enc->me_threshold= me_threshold;
3127
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3128

    
3129
        if (do_psnr)
3130
            video_enc->flags|= CODEC_FLAG_PSNR;
3131

    
3132
        /* two pass mode */
3133
        if (do_pass) {
3134
            if (do_pass == 1) {
3135
                video_enc->flags |= CODEC_FLAG_PASS1;
3136
            } else {
3137
                video_enc->flags |= CODEC_FLAG_PASS2;
3138
            }
3139
        }
3140
    }
3141
    nb_ocodecs++;
3142

    
3143
    /* reset some key parameters */
3144
    video_disable = 0;
3145
    av_freep(&video_codec_name);
3146
    video_stream_copy = 0;
3147
}
3148

    
3149
static void new_audio_stream(AVFormatContext *oc)
3150
{
3151
    AVStream *st;
3152
    AVCodecContext *audio_enc;
3153
    int codec_id;
3154

    
3155
    st = av_new_stream(oc, oc->nb_streams);
3156
    if (!st) {
3157
        fprintf(stderr, "Could not alloc stream\n");
3158
        av_exit(1);
3159
    }
3160
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3161

    
3162
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3163
    audio_bitstream_filters= NULL;
3164

    
3165
    if(thread_count>1)
3166
        avcodec_thread_init(st->codec, thread_count);
3167

    
3168
    audio_enc = st->codec;
3169
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3170

    
3171
    if(audio_codec_tag)
3172
        audio_enc->codec_tag= audio_codec_tag;
3173

    
3174
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3175
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3176
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3177
    }
3178
    if (audio_stream_copy) {
3179
        st->stream_copy = 1;
3180
        audio_enc->channels = audio_channels;
3181
    } else {
3182
        AVCodec *codec;
3183

    
3184
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3185

    
3186
        if (audio_codec_name) {
3187
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3188
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3189
            output_codecs[nb_ocodecs] = codec;
3190
        } else {
3191
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3192
            codec = avcodec_find_encoder(codec_id);
3193
        }
3194
        audio_enc->codec_id = codec_id;
3195

    
3196
        if (audio_qscale > QSCALE_NONE) {
3197
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3198
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3199
        }
3200
        audio_enc->thread_count = thread_count;
3201
        audio_enc->channels = audio_channels;
3202
        audio_enc->sample_fmt = audio_sample_fmt;
3203
        audio_enc->channel_layout = channel_layout;
3204

    
3205
        if(codec && codec->sample_fmts){
3206
            const enum SampleFormat *p= codec->sample_fmts;
3207
            for(; *p!=-1; p++){
3208
                if(*p == audio_enc->sample_fmt)
3209
                    break;
3210
            }
3211
            if(*p == -1)
3212
                audio_enc->sample_fmt = codec->sample_fmts[0];
3213
        }
3214
    }
3215
    nb_ocodecs++;
3216
    audio_enc->sample_rate = audio_sample_rate;
3217
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3218
    if (audio_language) {
3219
        av_metadata_set(&st->metadata, "language", audio_language);
3220
        av_free(audio_language);
3221
        audio_language = NULL;
3222
    }
3223

    
3224
    /* reset some key parameters */
3225
    audio_disable = 0;
3226
    av_freep(&audio_codec_name);
3227
    audio_stream_copy = 0;
3228
}
3229

    
3230
static void new_subtitle_stream(AVFormatContext *oc)
3231
{
3232
    AVStream *st;
3233
    AVCodecContext *subtitle_enc;
3234

    
3235
    st = av_new_stream(oc, oc->nb_streams);
3236
    if (!st) {
3237
        fprintf(stderr, "Could not alloc stream\n");
3238
        av_exit(1);
3239
    }
3240
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3241

    
3242
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3243
    subtitle_bitstream_filters= NULL;
3244

    
3245
    subtitle_enc = st->codec;
3246
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3247

    
3248
    if(subtitle_codec_tag)
3249
        subtitle_enc->codec_tag= subtitle_codec_tag;
3250

    
3251
    if (subtitle_stream_copy) {
3252
        st->stream_copy = 1;
3253
    } else {
3254
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3255
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3256
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3257
    }
3258
    nb_ocodecs++;
3259

    
3260
    if (subtitle_language) {
3261
        av_metadata_set(&st->metadata, "language", subtitle_language);
3262
        av_free(subtitle_language);
3263
        subtitle_language = NULL;
3264
    }
3265

    
3266
    subtitle_disable = 0;
3267
    av_freep(&subtitle_codec_name);
3268
    subtitle_stream_copy = 0;
3269
}
3270

    
3271
static void opt_new_audio_stream(void)
3272
{
3273
    AVFormatContext *oc;
3274
    if (nb_output_files <= 0) {
3275
        fprintf(stderr, "At least one output file must be specified\n");
3276
        av_exit(1);
3277
    }
3278
    oc = output_files[nb_output_files - 1];
3279
    new_audio_stream(oc);
3280
}
3281

    
3282
static void opt_new_video_stream(void)
3283
{
3284
    AVFormatContext *oc;
3285
    if (nb_output_files <= 0) {
3286
        fprintf(stderr, "At least one output file must be specified\n");
3287
        av_exit(1);
3288
    }
3289
    oc = output_files[nb_output_files - 1];
3290
    new_video_stream(oc);
3291
}
3292

    
3293
static void opt_new_subtitle_stream(void)
3294
{
3295
    AVFormatContext *oc;
3296
    if (nb_output_files <= 0) {
3297
        fprintf(stderr, "At least one output file must be specified\n");
3298
        av_exit(1);
3299
    }
3300
    oc = output_files[nb_output_files - 1];
3301
    new_subtitle_stream(oc);
3302
}
3303

    
3304
static void opt_output_file(const char *filename)
3305
{
3306
    AVFormatContext *oc;
3307
    int use_video, use_audio, use_subtitle;
3308
    int input_has_video, input_has_audio, input_has_subtitle;
3309
    AVFormatParameters params, *ap = &params;
3310

    
3311
    if (!strcmp(filename, "-"))
3312
        filename = "pipe:";
3313

    
3314
    oc = avformat_alloc_context();
3315

    
3316
    if (!file_oformat) {
3317
        file_oformat = guess_format(NULL, filename, NULL);
3318
        if (!file_oformat) {
3319
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3320
                    filename);
3321
            av_exit(1);
3322
        }
3323
    }
3324

    
3325
    oc->oformat = file_oformat;
3326
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3327

    
3328
    if (!strcmp(file_oformat->name, "ffm") &&
3329
        av_strstart(filename, "http:", NULL)) {
3330
        /* special case for files sent to ffserver: we get the stream
3331
           parameters from ffserver */
3332
        int err = read_ffserver_streams(oc, filename);
3333
        if (err < 0) {
3334
            print_error(filename, err);
3335
            av_exit(1);
3336
        }
3337
    } else {
3338
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3339
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3340
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3341

    
3342
        /* disable if no corresponding type found and at least one
3343
           input file */
3344
        if (nb_input_files > 0) {
3345
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3346
                                         &input_has_subtitle);
3347
            if (!input_has_video)
3348
                use_video = 0;
3349
            if (!input_has_audio)
3350
                use_audio = 0;
3351
            if (!input_has_subtitle)
3352
                use_subtitle = 0;
3353
        }
3354

    
3355
        /* manual disable */
3356
        if (audio_disable) {
3357
            use_audio = 0;
3358
        }
3359
        if (video_disable) {
3360
            use_video = 0;
3361
        }
3362
        if (subtitle_disable) {
3363
            use_subtitle = 0;
3364
        }
3365

    
3366
        if (use_video) {
3367
            new_video_stream(oc);
3368
        }
3369

    
3370
        if (use_audio) {
3371
            new_audio_stream(oc);
3372
        }
3373

    
3374
        if (use_subtitle) {
3375
            new_subtitle_stream(oc);
3376
        }
3377

    
3378
        oc->timestamp = rec_timestamp;
3379

    
3380
        for(; metadata_count>0; metadata_count--){
3381
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3382
                                           metadata[metadata_count-1].value);
3383
        }
3384
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3385
    }
3386

    
3387
    output_files[nb_output_files++] = oc;
3388

    
3389
    /* check filename in case of an image number is expected */
3390
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3391
        if (!av_filename_number_test(oc->filename)) {
3392
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3393
            av_exit(1);
3394
        }
3395
    }
3396

    
3397
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3398
        /* test if it already exists to avoid loosing precious files */
3399
        if (!file_overwrite &&
3400
            (strchr(filename, ':') == NULL ||
3401
             filename[1] == ':' ||
3402
             av_strstart(filename, "file:", NULL))) {
3403
            if (url_exist(filename)) {
3404
                if (!using_stdin) {
3405
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3406
                    fflush(stderr);
3407
                    if (!read_yesno()) {
3408
                        fprintf(stderr, "Not overwriting - exiting\n");
3409
                        av_exit(1);
3410
                    }
3411
                }
3412
                else {
3413
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3414
                    av_exit(1);
3415
                }
3416
            }
3417
        }
3418

    
3419
        /* open the file */
3420
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3421
            fprintf(stderr, "Could not open '%s'\n", filename);
3422
            av_exit(1);
3423
        }
3424
    }
3425

    
3426
    memset(ap, 0, sizeof(*ap));
3427
    if (av_set_parameters(oc, ap) < 0) {
3428
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3429
                oc->filename);
3430
        av_exit(1);
3431
    }
3432

    
3433
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3434
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3435
    oc->loop_output = loop_output;
3436
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3437

    
3438
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3439

    
3440
    /* reset some options */
3441
    file_oformat = NULL;
3442
    file_iformat = NULL;
3443
}
3444

    
3445
/* same option as mencoder */
3446
static void opt_pass(const char *pass_str)
3447
{
3448
    int pass;
3449
    pass = atoi(pass_str);
3450
    if (pass != 1 && pass != 2) {
3451
        fprintf(stderr, "pass number can be only 1 or 2\n");
3452
        av_exit(1);
3453
    }
3454
    do_pass = pass;
3455
}
3456

    
3457
static int64_t getutime(void)
3458
{
3459
#if HAVE_GETRUSAGE
3460
    struct rusage rusage;
3461

    
3462
    getrusage(RUSAGE_SELF, &rusage);
3463
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3464
#elif HAVE_GETPROCESSTIMES
3465
    HANDLE proc;
3466
    FILETIME c, e, k, u;
3467
    proc = GetCurrentProcess();
3468
    GetProcessTimes(proc, &c, &e, &k, &u);
3469
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3470
#else
3471
    return av_gettime();
3472
#endif
3473
}
3474

    
3475
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3476
{
3477
    int i;
3478
    const char *p = str;
3479
    for(i = 0;; i++) {
3480
        dest[i] = atoi(p);
3481
        if(i == 63)
3482
            break;
3483
        p = strchr(p, ',');
3484
        if(!p) {
3485
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3486
            av_exit(1);
3487
        }
3488
        p++;
3489
    }
3490
}
3491

    
3492
static void opt_inter_matrix(const char *arg)
3493
{
3494
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3495
    parse_matrix_coeffs(inter_matrix, arg);
3496
}
3497

    
3498
static void opt_intra_matrix(const char *arg)
3499
{
3500
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3501
    parse_matrix_coeffs(intra_matrix, arg);
3502
}
3503

    
3504
/**
3505
 * Trivial log callback.
3506
 * Only suitable for show_help and similar since it lacks prefix handling.
3507
 */
3508
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3509
{
3510
    vfprintf(stdout, fmt, vl);
3511
}
3512

    
3513
static void show_help(void)
3514
{
3515
    av_log_set_callback(log_callback_help);
3516
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3517
           "Hyper fast Audio and Video encoder\n");
3518
    printf("\n");
3519
    show_help_options(options, "Main options:\n",
3520
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3521
    show_help_options(options, "\nAdvanced options:\n",
3522
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3523
                      OPT_EXPERT);
3524
    show_help_options(options, "\nVideo options:\n",
3525
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3526
                      OPT_VIDEO);
3527
    show_help_options(options, "\nAdvanced Video options:\n",
3528
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3529
                      OPT_VIDEO | OPT_EXPERT);
3530
    show_help_options(options, "\nAudio options:\n",
3531
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3532
                      OPT_AUDIO);
3533
    show_help_options(options, "\nAdvanced Audio options:\n",
3534
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3535
                      OPT_AUDIO | OPT_EXPERT);
3536
    show_help_options(options, "\nSubtitle options:\n",
3537
                      OPT_SUBTITLE | OPT_GRAB,
3538
                      OPT_SUBTITLE);
3539
    show_help_options(options, "\nAudio/Video grab options:\n",
3540
                      OPT_GRAB,
3541
                      OPT_GRAB);
3542
    printf("\n");
3543
    av_opt_show(avcodec_opts[0], NULL);
3544
    printf("\n");
3545
    av_opt_show(avformat_opts, NULL);
3546
    printf("\n");
3547
    av_opt_show(sws_opts, NULL);
3548
}
3549

    
3550
static void opt_target(const char *arg)
3551
{
3552
    int norm = -1;
3553
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3554

    
3555
    if(!strncmp(arg, "pal-", 4)) {
3556
        norm = 0;
3557
        arg += 4;
3558
    } else if(!strncmp(arg, "ntsc-", 5)) {
3559
        norm = 1;
3560
        arg += 5;
3561
    } else if(!strncmp(arg, "film-", 5)) {
3562
        norm = 2;
3563
        arg += 5;
3564
    } else {
3565
        int fr;
3566
        /* Calculate FR via float to avoid int overflow */
3567
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3568
        if(fr == 25000) {
3569
            norm = 0;
3570
        } else if((fr == 29970) || (fr == 23976)) {
3571
            norm = 1;
3572
        } else {
3573
            /* Try to determine PAL/NTSC by peeking in the input files */
3574
            if(nb_input_files) {
3575
                int i, j;
3576
                for(j = 0; j < nb_input_files; j++) {
3577
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3578
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3579
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3580
                            continue;
3581
                        fr = c->time_base.den * 1000 / c->time_base.num;
3582
                        if(fr == 25000) {
3583
                            norm = 0;
3584
                            break;
3585
                        } else if((fr == 29970) || (fr == 23976)) {
3586
                            norm = 1;
3587
                            break;
3588
                        }
3589
                    }
3590
                    if(norm >= 0)
3591
                        break;
3592
                }
3593
            }
3594
        }
3595
        if(verbose && norm >= 0)
3596
            fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3597
    }
3598

    
3599
    if(norm < 0) {
3600
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3601
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3602
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3603
        av_exit(1);
3604
    }
3605

    
3606
    if(!strcmp(arg, "vcd")) {
3607

    
3608
        opt_video_codec("mpeg1video");
3609
        opt_audio_codec("mp2");
3610
        opt_format("vcd");
3611

    
3612
        opt_frame_size(norm ? "352x240" : "352x288");
3613
        opt_frame_rate(NULL, frame_rates[norm]);
3614
        opt_default("gop", norm ? "18" : "15");
3615

    
3616
        opt_default("b", "1150000");
3617
        opt_default("maxrate", "1150000");
3618
        opt_default("minrate", "1150000");
3619
        opt_default("bufsize", "327680"); // 40*1024*8;
3620

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

    
3625
        opt_default("packetsize", "2324");
3626
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3627

    
3628
        /* We have to offset the PTS, so that it is consistent with the SCR.
3629
           SCR starts at 36000, but the first two packs contain only padding
3630
           and the first pack from the other stream, respectively, may also have
3631
           been written before.
3632
           So the real data starts at SCR 36000+3*1200. */
3633
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3634
    } else if(!strcmp(arg, "svcd")) {
3635

    
3636
        opt_video_codec("mpeg2video");
3637
        opt_audio_codec("mp2");
3638
        opt_format("svcd");
3639

    
3640
        opt_frame_size(norm ? "480x480" : "480x576");
3641
        opt_frame_rate(NULL, frame_rates[norm]);
3642
        opt_default("gop", norm ? "18" : "15");
3643

    
3644
        opt_default("b", "2040000");
3645
        opt_default("maxrate", "2516000");
3646
        opt_default("minrate", "0"); //1145000;
3647
        opt_default("bufsize", "1835008"); //224*1024*8;
3648
        opt_default("flags", "+scan_offset");
3649

    
3650

    
3651
        opt_default("ab", "224000");
3652
        audio_sample_rate = 44100;
3653

    
3654
        opt_default("packetsize", "2324");
3655

    
3656
    } else if(!strcmp(arg, "dvd")) {
3657

    
3658
        opt_video_codec("mpeg2video");
3659
        opt_audio_codec("ac3");
3660
        opt_format("dvd");
3661

    
3662
        opt_frame_size(norm ? "720x480" : "720x576");
3663
        opt_frame_rate(NULL, frame_rates[norm]);
3664
        opt_default("gop", norm ? "18" : "15");
3665

    
3666
        opt_default("b", "6000000");
3667
        opt_default("maxrate", "9000000");
3668
        opt_default("minrate", "0"); //1500000;
3669
        opt_default("bufsize", "1835008"); //224*1024*8;
3670

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

    
3674
        opt_default("ab", "448000");
3675
        audio_sample_rate = 48000;
3676

    
3677
    } else if(!strncmp(arg, "dv", 2)) {
3678

    
3679
        opt_format("dv");
3680

    
3681
        opt_frame_size(norm ? "720x480" : "720x576");
3682
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3683
                                             (norm ? "yuv411p" : "yuv420p"));
3684
        opt_frame_rate(NULL, frame_rates[norm]);
3685

    
3686
        audio_sample_rate = 48000;
3687
        audio_channels = 2;
3688

    
3689
    } else {
3690
        fprintf(stderr, "Unknown target: %s\n", arg);
3691
        av_exit(1);
3692
    }
3693
}
3694

    
3695
static void opt_vstats_file (const char *arg)
3696
{
3697
    av_free (vstats_filename);
3698
    vstats_filename=av_strdup (arg);
3699
}
3700

    
3701
static void opt_vstats (void)
3702
{
3703
    char filename[40];
3704
    time_t today2 = time(NULL);
3705
    struct tm *today = localtime(&today2);
3706

    
3707
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3708
             today->tm_sec);
3709
    opt_vstats_file(filename);
3710
}
3711

    
3712
static int opt_bsf(const char *opt, const char *arg)
3713
{
3714
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3715
    AVBitStreamFilterContext **bsfp;
3716

    
3717
    if(!bsfc){
3718
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3719
        av_exit(1);
3720
    }
3721

    
3722
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3723
          *opt == 'a' ? &audio_bitstream_filters :
3724
                        &subtitle_bitstream_filters;
3725
    while(*bsfp)
3726
        bsfp= &(*bsfp)->next;
3727

    
3728
    *bsfp= bsfc;
3729

    
3730
    return 0;
3731
}
3732

    
3733
static int opt_preset(const char *opt, const char *arg)
3734
{
3735
    FILE *f=NULL;
3736
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3737
    int i;
3738
    const char *base[2]= { getenv("HOME"),
3739
                           FFMPEG_DATADIR,
3740
                         };
3741

    
3742
    for(i=!base[0]; i<2 && !f; i++){
3743
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3744
        f= fopen(filename, "r");
3745
        if(!f){
3746
            char *codec_name= *opt == 'v' ? video_codec_name :
3747
                              *opt == 'a' ? audio_codec_name :
3748
                                            subtitle_codec_name;
3749
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3750
            f= fopen(filename, "r");
3751
        }
3752
    }
3753
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3754
              is_dos_path(arg))){
3755
        av_strlcpy(filename, arg, sizeof(filename));
3756
        f= fopen(filename, "r");
3757
    }
3758

    
3759
    if(!f){
3760
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3761
        av_exit(1);
3762
    }
3763

    
3764
    while(!feof(f)){
3765
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3766
        if(line[0] == '#' && !e)
3767
            continue;
3768
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3769
        if(e){
3770
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3771
            av_exit(1);
3772
        }
3773
        if(!strcmp(tmp, "acodec")){
3774
            opt_audio_codec(tmp2);
3775
        }else if(!strcmp(tmp, "vcodec")){
3776
            opt_video_codec(tmp2);
3777
        }else if(!strcmp(tmp, "scodec")){
3778
            opt_subtitle_codec(tmp2);
3779
        }else if(opt_default(tmp, tmp2) < 0){
3780
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3781
            av_exit(1);
3782
        }
3783
    }
3784

    
3785
    fclose(f);
3786

    
3787
    return 0;
3788
}
3789

    
3790
static const OptionDef options[] = {
3791
    /* main options */
3792
    { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3793
    { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3794
    { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3795
    { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3796
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3797
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3798
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3799
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3800
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3801
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3802
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3803
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3804
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3805
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3806
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3807
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)&opt_metadata}, "add metadata", "string=string" },
3808
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3809
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3810
      "add timings for benchmarking" },
3811
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3812
      "dump each input packet" },
3813
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3814
      "when dumping packets, also dump the payload" },
3815
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3816
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3817
    { "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)", "" },
3818
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3819
    { "loglevel", HAS_ARG | OPT_FUNC2, {(void*)opt_loglevel}, "set libav* logging level", "number" },
3820
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3821
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3822
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3823
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3824
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3825
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3826
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3827
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3828
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3829
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3830
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3831
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3832

    
3833
    /* video options */
3834
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3835
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3836
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3837
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3838
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3839
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3840
    { "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" },
3841
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3842
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3843
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3844
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3845
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3846
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3847
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3848
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3849
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3850
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3851
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3852
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3853
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3854
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3855
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3856
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3857
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3858
      "use same video quality as source (implies VBR)" },
3859
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3860
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3861
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3862
      "deinterlace pictures" },
3863
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3864
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3865
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3866
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3867
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3868
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3869
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3870
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3871
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3872
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3873
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3874

    
3875
    /* audio options */
3876
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3877
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3878
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3879
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3880
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3881
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3882
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3883
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3884
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3885
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3886
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3887
    { "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" },
3888

    
3889
    /* subtitle options */
3890
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3891
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3892
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3893
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3894
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3895

    
3896
    /* grab options */
3897
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3898
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3899
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3900

    
3901
    /* muxer options */
3902
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3903
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3904

    
3905
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3906
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3907
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3908

    
3909
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3910
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3911
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3912

    
3913
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3914
    { NULL, },
3915
};
3916

    
3917
int main(int argc, char **argv)
3918
{
3919
    int i;
3920
    int64_t ti;
3921

    
3922
    avcodec_register_all();
3923
    avdevice_register_all();
3924
    av_register_all();
3925

    
3926
    if(isatty(STDIN_FILENO))
3927
        url_set_interrupt_cb(decode_interrupt_cb);
3928

    
3929
    for(i=0; i<CODEC_TYPE_NB; i++){
3930
        avcodec_opts[i]= avcodec_alloc_context2(i);
3931
    }
3932
    avformat_opts = avformat_alloc_context();
3933
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3934

    
3935
    show_banner();
3936

    
3937
    /* parse options */
3938
    parse_options(argc, argv, options, opt_output_file);
3939

    
3940
    /* file converter / grab */
3941
    if (nb_output_files <= 0) {
3942
        fprintf(stderr, "At least one output file must be specified\n");
3943
        av_exit(1);
3944
    }
3945

    
3946
    if (nb_input_files == 0) {
3947
        fprintf(stderr, "At least one input file must be specified\n");
3948
        av_exit(1);
3949
    }
3950

    
3951
    ti = getutime();
3952
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3953
                  stream_maps, nb_stream_maps) < 0)
3954
        av_exit(1);
3955
    ti = getutime() - ti;
3956
    if (do_benchmark) {
3957
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3958
    }
3959

    
3960
    return av_exit(0);
3961
}