Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 4c97a6fa

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 "libavcodec/colorspace.h"
40
#include "libavutil/fifo.h"
41
#include "libavutil/avstring.h"
42
#include "libavformat/os_support.h"
43

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

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

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

    
66
#include "cmdutils.h"
67

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

    
71
#undef exit
72

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

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

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

    
90
static const OptionDef options[];
91

    
92
#define MAX_FILES 20
93

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

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

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

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

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

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

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

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

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

    
198
static int rate_emu = 0;
199

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

    
203
static int audio_volume = 256;
204

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

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

    
222
static unsigned int sws_flags = SWS_BICUBIC;
223

    
224
static int64_t timer_start;
225

    
226
static uint8_t *audio_buf;
227
static uint8_t *audio_out;
228
static uint8_t *audio_out2;
229

    
230
static short *samples;
231

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

    
237
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
238

    
239
struct AVInputStream;
240

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

    
259
    int video_crop;
260
    int topBand;             /* cropping area sizes */
261
    int leftBand;
262

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

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

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

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

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

    
300
#if HAVE_TERMIOS_H
301

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

    
306
static void term_exit(void)
307
{
308
#if HAVE_TERMIOS_H
309
    tcsetattr (0, TCSANOW, &oldtty);
310
#endif
311
}
312

    
313
static volatile sig_atomic_t received_sigterm = 0;
314

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

    
322
static void term_init(void)
323
{
324
#if HAVE_TERMIOS_H
325
    struct termios tty;
326

    
327
    tcgetattr (0, &tty);
328
    oldtty = tty;
329

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

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

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

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

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

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

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

    
389
static int av_exit(int ret)
390
{
391
    int i;
392

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

    
417
    av_free(intra_matrix);
418
    av_free(inter_matrix);
419

    
420
    if (vstats_file)
421
        fclose(vstats_file);
422
    av_free(vstats_filename);
423

    
424
    av_free(opt_names);
425

    
426
    av_free(video_codec_name);
427
    av_free(audio_codec_name);
428
    av_free(subtitle_codec_name);
429

    
430
    av_free(video_standard);
431

    
432
#if CONFIG_POWERPC_PERF
433
    void powerpc_display_perf_report(void);
434
    powerpc_display_perf_report();
435
#endif /* CONFIG_POWERPC_PERF */
436

    
437
    for (i=0;i<CODEC_TYPE_NB;i++)
438
        av_free(avcodec_opts[i]);
439
    av_free(avformat_opts);
440
    av_free(sws_opts);
441
    av_free(audio_buf);
442
    av_free(audio_out);
443
    av_free(audio_out2);
444
    av_free(samples);
445

    
446
    if (received_sigterm) {
447
        fprintf(stderr,
448
            "Received signal %d: terminating.\n",
449
            (int) received_sigterm);
450
        exit (255);
451
    }
452

    
453
    exit(ret); /* not all OS-es handle main() return value */
454
    return ret;
455
}
456

    
457
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
458
{
459
    int i, err;
460
    AVFormatContext *ic;
461
    int nopts = 0;
462

    
463
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
464
    if (err < 0)
465
        return err;
466
    /* copy stream format */
467
    s->nb_streams = ic->nb_streams;
468
    for(i=0;i<ic->nb_streams;i++) {
469
        AVStream *st;
470

    
471
        // FIXME: a more elegant solution is needed
472
        st = av_mallocz(sizeof(AVStream));
473
        memcpy(st, ic->streams[i], sizeof(AVStream));
474
        st->codec = avcodec_alloc_context();
475
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
476
        s->streams[i] = st;
477

    
478
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
479
            st->stream_copy = 1;
480
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
481
            st->stream_copy = 1;
482

    
483
        if(!st->codec->thread_count)
484
            st->codec->thread_count = 1;
485
        if(st->codec->thread_count>1)
486
            avcodec_thread_init(st->codec, st->codec->thread_count);
487

    
488
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
489
            nopts = 1;
490
    }
491

    
492
    if (!nopts)
493
        s->timestamp = av_gettime();
494

    
495
    av_close_input_file(ic);
496
    return 0;
497
}
498

    
499
static double
500
get_sync_ipts(const AVOutputStream *ost)
501
{
502
    const AVInputStream *ist = ost->sync_ist;
503
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
504
}
505

    
506
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
507
    int ret;
508

    
509
    while(bsfc){
510
        AVPacket new_pkt= *pkt;
511
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
512
                                          &new_pkt.data, &new_pkt.size,
513
                                          pkt->data, pkt->size,
514
                                          pkt->flags & PKT_FLAG_KEY);
515
        if(a>0){
516
            av_free_packet(pkt);
517
            new_pkt.destruct= av_destruct_packet;
518
        } else if(a<0){
519
            fprintf(stderr, "%s failed for stream %d, codec %s",
520
                    bsfc->filter->name, pkt->stream_index,
521
                    avctx->codec ? avctx->codec->name : "copy");
522
            print_error("", a);
523
            if (exit_on_error)
524
                av_exit(1);
525
        }
526
        *pkt= new_pkt;
527

    
528
        bsfc= bsfc->next;
529
    }
530

    
531
    ret= av_interleaved_write_frame(s, pkt);
532
    if(ret < 0){
533
        print_error("av_interleaved_write_frame()", ret);
534
        av_exit(1);
535
    }
536
}
537

    
538
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
539

    
540
static void do_audio_out(AVFormatContext *s,
541
                         AVOutputStream *ost,
542
                         AVInputStream *ist,
543
                         unsigned char *buf, int size)
544
{
545
    uint8_t *buftmp;
546
    const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
547

    
548
    int size_out, frame_bytes, ret;
549
    AVCodecContext *enc= ost->st->codec;
550
    AVCodecContext *dec= ist->st->codec;
551
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
552
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
553

    
554
    /* SC: dynamic allocation of buffers */
555
    if (!audio_buf)
556
        audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
557
    if (!audio_out)
558
        audio_out = av_malloc(audio_out_size);
559
    if (!audio_buf || !audio_out)
560
        return;               /* Should signal an error ! */
561

    
562
    if (enc->channels != dec->channels)
563
        ost->audio_resample = 1;
564

    
565
    if (ost->audio_resample && !ost->resample) {
566
        if (dec->sample_fmt != SAMPLE_FMT_S16)
567
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
568
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
569
                                               enc->sample_rate, dec->sample_rate,
570
                                               enc->sample_fmt,  dec->sample_fmt,
571
                                               16, 10, 0, 0.8);
572
        if (!ost->resample) {
573
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
574
                    dec->channels, dec->sample_rate,
575
                    enc->channels, enc->sample_rate);
576
            av_exit(1);
577
        }
578
    }
579

    
580
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
581
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
582
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
583
        if (!audio_out2)
584
            audio_out2 = av_malloc(audio_out_size);
585
        if (!audio_out2)
586
            av_exit(1);
587
        if (ost->reformat_ctx)
588
            av_audio_convert_free(ost->reformat_ctx);
589
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
590
                                                   dec->sample_fmt, 1, NULL, 0);
591
        if (!ost->reformat_ctx) {
592
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
593
                avcodec_get_sample_fmt_name(dec->sample_fmt),
594
                avcodec_get_sample_fmt_name(enc->sample_fmt));
595
            av_exit(1);
596
        }
597
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
598
    }
599

    
600
    if(audio_sync_method){
601
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
602
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
603
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
604
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
605

    
606
        //FIXME resample delay
607
        if(fabs(delta) > 50){
608
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
609
                if(byte_delta < 0){
610
                    byte_delta= FFMAX(byte_delta, -size);
611
                    size += byte_delta;
612
                    buf  -= byte_delta;
613
                    if(verbose > 2)
614
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
615
                    if(!size)
616
                        return;
617
                    ist->is_start=0;
618
                }else{
619
                    static uint8_t *input_tmp= NULL;
620
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
621

    
622
                    if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
623
                        ist->is_start=0;
624
                    else
625
                        byte_delta= MAX_AUDIO_PACKET_SIZE - size;
626

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

    
647
    if (ost->audio_resample) {
648
        buftmp = audio_buf;
649
        size_out = audio_resample(ost->resample,
650
                                  (short *)buftmp, (short *)buf,
651
                                  size / (ist->st->codec->channels * isize));
652
        size_out = size_out * enc->channels * osize;
653
    } else {
654
        buftmp = buf;
655
        size_out = size;
656
    }
657

    
658
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
659
        const void *ibuf[6]= {buftmp};
660
        void *obuf[6]= {audio_out2};
661
        int istride[6]= {isize};
662
        int ostride[6]= {osize};
663
        int len= size_out/istride[0];
664
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
665
            printf("av_audio_convert() failed\n");
666
            if (exit_on_error)
667
                av_exit(1);
668
            return;
669
        }
670
        buftmp = audio_out2;
671
        size_out = len*osize;
672
    }
673

    
674
    /* now encode as many frames as possible */
675
    if (enc->frame_size > 1) {
676
        /* output resampled raw samples */
677
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
678
            fprintf(stderr, "av_fifo_realloc2() failed\n");
679
            av_exit(1);
680
        }
681
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
682

    
683
        frame_bytes = enc->frame_size * osize * enc->channels;
684

    
685
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
686
            AVPacket pkt;
687
            av_init_packet(&pkt);
688

    
689
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
690

    
691
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
692

    
693
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
694
                                       (short *)audio_buf);
695
            if (ret < 0) {
696
                fprintf(stderr, "Audio encoding failed\n");
697
                av_exit(1);
698
            }
699
            audio_size += ret;
700
            pkt.stream_index= ost->index;
701
            pkt.data= audio_out;
702
            pkt.size= ret;
703
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
704
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
705
            pkt.flags |= PKT_FLAG_KEY;
706
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
707

    
708
            ost->sync_opts += enc->frame_size;
709
        }
710
    } else {
711
        AVPacket pkt;
712
        int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
713
        av_init_packet(&pkt);
714

    
715
        ost->sync_opts += size_out / (osize * enc->channels);
716

    
717
        /* output a pcm frame */
718
        /* determine the size of the coded buffer */
719
        size_out /= osize;
720
        if (coded_bps)
721
            size_out *= coded_bps;
722

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

    
741
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
742
{
743
    AVCodecContext *dec;
744
    AVPicture *picture2;
745
    AVPicture picture_tmp;
746
    uint8_t *buf = 0;
747

    
748
    dec = ist->st->codec;
749

    
750
    /* deinterlace : must be done before any resize */
751
    if (do_deinterlace) {
752
        int size;
753

    
754
        /* create temporary picture */
755
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
756
        buf = av_malloc(size);
757
        if (!buf)
758
            return;
759

    
760
        picture2 = &picture_tmp;
761
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
762

    
763
        if(avpicture_deinterlace(picture2, picture,
764
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
765
            /* if error, do not deinterlace */
766
            fprintf(stderr, "Deinterlacing failed\n");
767
            av_free(buf);
768
            buf = NULL;
769
            picture2 = picture;
770
        }
771
    } else {
772
        picture2 = picture;
773
    }
774

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
860
    *frame_size = 0;
861

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

    
888
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
889
    if (nb_frames <= 0)
890
        return;
891

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

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

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

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

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

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

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

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

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

    
986
            if(ret>0){
987
                pkt.data= bit_buffer;
988
                pkt.size= ret;
989
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
990
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
991
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
992
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
993
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
994

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

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

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

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

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

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

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

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

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

    
1081

    
1082
    oc = output_files[0];
1083

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

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

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

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

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

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

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

    
1162
        fflush(stderr);
1163
    }
1164

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

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

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

    
1197
    if (pkt == NULL) {
1198
        /* EOF handling */
1199
        av_init_packet(&avpkt);
1200
        avpkt.data = NULL;
1201
        avpkt.size = 0;
1202
        goto handle_eof;
1203
    } else {
1204
        avpkt = *pkt;
1205
    }
1206

    
1207
    if(pkt->dts != AV_NOPTS_VALUE)
1208
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1209

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

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

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

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

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

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

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

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

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

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

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

    
1375
                        av_init_packet(&opkt);
1376

    
1377
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1378
                            continue;
1379

    
1380
                        /* no reencoding needed : output the packet directly */
1381
                        /* force the input stream PTS */
1382

    
1383
                        avcodec_get_frame_defaults(&avframe);
1384
                        ost->st->codec->coded_frame= &avframe;
1385
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1386

    
1387
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1388
                            audio_size += data_size;
1389
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1390
                            video_size += data_size;
1391
                            ost->sync_opts++;
1392
                        }
1393

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

    
1400
                        if (pkt->dts == AV_NOPTS_VALUE)
1401
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1402
                        else
1403
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1404
                        opkt.dts -= ost_tb_start_time;
1405

    
1406
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1407
                        opkt.flags= pkt->flags;
1408

    
1409
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1410
                        if(ost->st->codec->codec_id != CODEC_ID_H264) {
1411
                        if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1412
                            opkt.destruct= av_destruct_packet;
1413
                        } else {
1414
                            opkt.data = data_buf;
1415
                            opkt.size = data_size;
1416
                        }
1417

    
1418
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1419
                        ost->st->codec->frame_number++;
1420
                        ost->frame_number++;
1421
                        av_free_packet(&opkt);
1422
                    }
1423
                }
1424
            }
1425
        av_free(buffer_to_free);
1426
        /* XXX: allocate the subtitles in the codec ? */
1427
        if (subtitle_to_free) {
1428
            if (subtitle_to_free->rects != NULL) {
1429
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1430
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1431
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1432
                    av_freep(&subtitle_to_free->rects[i]);
1433
                }
1434
                av_freep(&subtitle_to_free->rects);
1435
            }
1436
            subtitle_to_free->num_rects = 0;
1437
            subtitle_to_free = NULL;
1438
        }
1439
    }
1440
 discard_packet:
1441
    if (pkt == NULL) {
1442
        /* EOF handling */
1443

    
1444
        for(i=0;i<nb_ostreams;i++) {
1445
            ost = ost_table[i];
1446
            if (ost->source_index == ist_index) {
1447
                AVCodecContext *enc= ost->st->codec;
1448
                os = output_files[ost->file_index];
1449

    
1450
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1451
                    continue;
1452
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1453
                    continue;
1454

    
1455
                if (ost->encoding_needed) {
1456
                    for(;;) {
1457
                        AVPacket pkt;
1458
                        int fifo_bytes;
1459
                        av_init_packet(&pkt);
1460
                        pkt.stream_index= ost->index;
1461

    
1462
                        switch(ost->st->codec->codec_type) {
1463
                        case CODEC_TYPE_AUDIO:
1464
                            fifo_bytes = av_fifo_size(ost->fifo);
1465
                            ret = 0;
1466
                            /* encode any samples remaining in fifo */
1467
                            if (fifo_bytes > 0) {
1468
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1469
                                int fs_tmp = enc->frame_size;
1470

    
1471
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1472
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1473
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1474
                                } else { /* pad */
1475
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1476
                                    if (samples_size < frame_bytes)
1477
                                        av_exit(1);
1478
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1479
                                }
1480

    
1481
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1482
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1483
                                                          ost->st->time_base.num, enc->sample_rate);
1484
                                enc->frame_size = fs_tmp;
1485
                            }
1486
                            if(ret <= 0) {
1487
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1488
                            }
1489
                            if (ret < 0) {
1490
                                fprintf(stderr, "Audio encoding failed\n");
1491
                                av_exit(1);
1492
                            }
1493
                            audio_size += ret;
1494
                            pkt.flags |= PKT_FLAG_KEY;
1495
                            break;
1496
                        case CODEC_TYPE_VIDEO:
1497
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1498
                            if (ret < 0) {
1499
                                fprintf(stderr, "Video encoding failed\n");
1500
                                av_exit(1);
1501
                            }
1502
                            video_size += ret;
1503
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1504
                                pkt.flags |= PKT_FLAG_KEY;
1505
                            if (ost->logfile && enc->stats_out) {
1506
                                fprintf(ost->logfile, "%s", enc->stats_out);
1507
                            }
1508
                            break;
1509
                        default:
1510
                            ret=-1;
1511
                        }
1512

    
1513
                        if(ret<=0)
1514
                            break;
1515
                        pkt.data= bit_buffer;
1516
                        pkt.size= ret;
1517
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1518
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1519
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1520
                    }
1521
                }
1522
            }
1523
        }
1524
    }
1525

    
1526
    return 0;
1527
 fail_decode:
1528
    return -1;
1529
}
1530

    
1531
static void print_sdp(AVFormatContext **avc, int n)
1532
{
1533
    char sdp[2048];
1534

    
1535
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1536
    printf("SDP:\n%s\n", sdp);
1537
    fflush(stdout);
1538
}
1539

    
1540
static int stream_index_from_inputs(AVFormatContext **input_files,
1541
                                    int nb_input_files,
1542
                                    AVInputFile *file_table,
1543
                                    AVInputStream **ist_table,
1544
                                    enum CodecType type,
1545
                                    int programid)
1546
{
1547
    int p, q, z;
1548
    for(z=0; z<nb_input_files; z++) {
1549
        AVFormatContext *ic = input_files[z];
1550
        for(p=0; p<ic->nb_programs; p++) {
1551
            AVProgram *program = ic->programs[p];
1552
            if(program->id != programid)
1553
                continue;
1554
            for(q=0; q<program->nb_stream_indexes; q++) {
1555
                int sidx = program->stream_index[q];
1556
                int ris = file_table[z].ist_index + sidx;
1557
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1558
                    return ris;
1559
            }
1560
        }
1561
    }
1562

    
1563
    return -1;
1564
}
1565

    
1566
/*
1567
 * The following code is the main loop of the file converter
1568
 */
1569
static int av_encode(AVFormatContext **output_files,
1570
                     int nb_output_files,
1571
                     AVFormatContext **input_files,
1572
                     int nb_input_files,
1573
                     AVStreamMap *stream_maps, int nb_stream_maps)
1574
{
1575
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1576
    AVFormatContext *is, *os;
1577
    AVCodecContext *codec, *icodec;
1578
    AVOutputStream *ost, **ost_table = NULL;
1579
    AVInputStream *ist, **ist_table = NULL;
1580
    AVInputFile *file_table;
1581
    char error[1024];
1582
    int key;
1583
    int want_sdp = 1;
1584
    uint8_t no_packet[MAX_FILES]={0};
1585
    int no_packet_count=0;
1586

    
1587
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1588
    if (!file_table)
1589
        goto fail;
1590

    
1591
    /* input stream init */
1592
    j = 0;
1593
    for(i=0;i<nb_input_files;i++) {
1594
        is = input_files[i];
1595
        file_table[i].ist_index = j;
1596
        file_table[i].nb_streams = is->nb_streams;
1597
        j += is->nb_streams;
1598
    }
1599
    nb_istreams = j;
1600

    
1601
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1602
    if (!ist_table)
1603
        goto fail;
1604

    
1605
    for(i=0;i<nb_istreams;i++) {
1606
        ist = av_mallocz(sizeof(AVInputStream));
1607
        if (!ist)
1608
            goto fail;
1609
        ist_table[i] = ist;
1610
    }
1611
    j = 0;
1612
    for(i=0;i<nb_input_files;i++) {
1613
        is = input_files[i];
1614
        for(k=0;k<is->nb_streams;k++) {
1615
            ist = ist_table[j++];
1616
            ist->st = is->streams[k];
1617
            ist->file_index = i;
1618
            ist->index = k;
1619
            ist->discard = 1; /* the stream is discarded by default
1620
                                 (changed later) */
1621

    
1622
            if (rate_emu) {
1623
                ist->start = av_gettime();
1624
            }
1625
        }
1626
    }
1627

    
1628
    /* output stream init */
1629
    nb_ostreams = 0;
1630
    for(i=0;i<nb_output_files;i++) {
1631
        os = output_files[i];
1632
        if (!os->nb_streams) {
1633
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1634
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1635
            av_exit(1);
1636
        }
1637
        nb_ostreams += os->nb_streams;
1638
    }
1639
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1640
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1641
        av_exit(1);
1642
    }
1643

    
1644
    /* Sanity check the mapping args -- do the input files & streams exist? */
1645
    for(i=0;i<nb_stream_maps;i++) {
1646
        int fi = stream_maps[i].file_index;
1647
        int si = stream_maps[i].stream_index;
1648

    
1649
        if (fi < 0 || fi > nb_input_files - 1 ||
1650
            si < 0 || si > file_table[fi].nb_streams - 1) {
1651
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1652
            av_exit(1);
1653
        }
1654
        fi = stream_maps[i].sync_file_index;
1655
        si = stream_maps[i].sync_stream_index;
1656
        if (fi < 0 || fi > nb_input_files - 1 ||
1657
            si < 0 || si > file_table[fi].nb_streams - 1) {
1658
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1659
            av_exit(1);
1660
        }
1661
    }
1662

    
1663
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1664
    if (!ost_table)
1665
        goto fail;
1666
    for(i=0;i<nb_ostreams;i++) {
1667
        ost = av_mallocz(sizeof(AVOutputStream));
1668
        if (!ost)
1669
            goto fail;
1670
        ost_table[i] = ost;
1671
    }
1672

    
1673
    n = 0;
1674
    for(k=0;k<nb_output_files;k++) {
1675
        os = output_files[k];
1676
        for(i=0;i<os->nb_streams;i++,n++) {
1677
            int found;
1678
            ost = ost_table[n];
1679
            ost->file_index = k;
1680
            ost->index = i;
1681
            ost->st = os->streams[i];
1682
            if (nb_stream_maps > 0) {
1683
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1684
                    stream_maps[n].stream_index;
1685

    
1686
                /* Sanity check that the stream types match */
1687
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1688
                    int i= ost->file_index;
1689
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1690
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1691
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1692
                        ost->file_index, ost->index);
1693
                    av_exit(1);
1694
                }
1695

    
1696
            } else {
1697
                if(opt_programid) {
1698
                    found = 0;
1699
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1700
                    if(j != -1) {
1701
                        ost->source_index = j;
1702
                        found = 1;
1703
                    }
1704
                } else {
1705
                    /* get corresponding input stream index : we select the first one with the right type */
1706
                    found = 0;
1707
                    for(j=0;j<nb_istreams;j++) {
1708
                        ist = ist_table[j];
1709
                        if (ist->discard &&
1710
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1711
                            ost->source_index = j;
1712
                            found = 1;
1713
                            break;
1714
                        }
1715
                    }
1716
                }
1717

    
1718
                if (!found) {
1719
                    if(! opt_programid) {
1720
                        /* try again and reuse existing stream */
1721
                        for(j=0;j<nb_istreams;j++) {
1722
                            ist = ist_table[j];
1723
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1724
                                ost->source_index = j;
1725
                                found = 1;
1726
                            }
1727
                        }
1728
                    }
1729
                    if (!found) {
1730
                        int i= ost->file_index;
1731
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1732
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1733
                                ost->file_index, ost->index);
1734
                        av_exit(1);
1735
                    }
1736
                }
1737
            }
1738
            ist = ist_table[ost->source_index];
1739
            ist->discard = 0;
1740
            ost->sync_ist = (nb_stream_maps > 0) ?
1741
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1742
                         stream_maps[n].sync_stream_index] : ist;
1743
        }
1744
    }
1745

    
1746
    /* for each output stream, we compute the right encoding parameters */
1747
    for(i=0;i<nb_ostreams;i++) {
1748
        AVMetadataTag *lang;
1749
        ost = ost_table[i];
1750
        os = output_files[ost->file_index];
1751
        ist = ist_table[ost->source_index];
1752

    
1753
        codec = ost->st->codec;
1754
        icodec = ist->st->codec;
1755

    
1756
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1757
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1758
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1759

    
1760
        ost->st->disposition = ist->st->disposition;
1761
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1762
        codec->chroma_sample_location = icodec->chroma_sample_location;
1763

    
1764
        if (ost->st->stream_copy) {
1765
            /* if stream_copy is selected, no need to decode or encode */
1766
            codec->codec_id = icodec->codec_id;
1767
            codec->codec_type = icodec->codec_type;
1768

    
1769
            if(!codec->codec_tag){
1770
                if(   !os->oformat->codec_tag
1771
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1772
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1773
                    codec->codec_tag = icodec->codec_tag;
1774
            }
1775

    
1776
            codec->bit_rate = icodec->bit_rate;
1777
            codec->extradata= icodec->extradata;
1778
            codec->extradata_size= icodec->extradata_size;
1779
            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){
1780
                codec->time_base = icodec->time_base;
1781
                codec->time_base.num *= icodec->ticks_per_frame;
1782
            }else
1783
                codec->time_base = ist->st->time_base;
1784
            switch(codec->codec_type) {
1785
            case CODEC_TYPE_AUDIO:
1786
                if(audio_volume != 256) {
1787
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1788
                    av_exit(1);
1789
                }
1790
                codec->channel_layout = icodec->channel_layout;
1791
                codec->sample_rate = icodec->sample_rate;
1792
                codec->channels = icodec->channels;
1793
                codec->frame_size = icodec->frame_size;
1794
                codec->block_align= icodec->block_align;
1795
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1796
                    codec->block_align= 0;
1797
                if(codec->codec_id == CODEC_ID_AC3)
1798
                    codec->block_align= 0;
1799
                break;
1800
            case CODEC_TYPE_VIDEO:
1801
                codec->pix_fmt = icodec->pix_fmt;
1802
                codec->width = icodec->width;
1803
                codec->height = icodec->height;
1804
                codec->has_b_frames = icodec->has_b_frames;
1805
                break;
1806
            case CODEC_TYPE_SUBTITLE:
1807
                codec->width = icodec->width;
1808
                codec->height = icodec->height;
1809
                break;
1810
            default:
1811
                abort();
1812
            }
1813
        } else {
1814
            switch(codec->codec_type) {
1815
            case CODEC_TYPE_AUDIO:
1816
                ost->fifo= av_fifo_alloc(1024);
1817
                if(!ost->fifo)
1818
                    goto fail;
1819
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1820
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1821
                icodec->request_channels = codec->channels;
1822
                ist->decoding_needed = 1;
1823
                ost->encoding_needed = 1;
1824
                break;
1825
            case CODEC_TYPE_VIDEO:
1826
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1827
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1828
                    av_exit(1);
1829
                }
1830
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1831
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1832
                ost->video_resample = ((codec->width != icodec->width -
1833
                                (frame_leftBand + frame_rightBand) +
1834
                                (frame_padleft + frame_padright)) ||
1835
                        (codec->height != icodec->height -
1836
                                (frame_topBand  + frame_bottomBand) +
1837
                                (frame_padtop + frame_padbottom)) ||
1838
                        (codec->pix_fmt != icodec->pix_fmt));
1839
                if (ost->video_crop) {
1840
                    ost->topBand = frame_topBand;
1841
                    ost->leftBand = frame_leftBand;
1842
                }
1843
                if (ost->video_pad) {
1844
                    ost->padtop = frame_padtop;
1845
                    ost->padleft = frame_padleft;
1846
                    ost->padbottom = frame_padbottom;
1847
                    ost->padright = frame_padright;
1848
                    if (!ost->video_resample) {
1849
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1850
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1851
                                         codec->width, codec->height))
1852
                            goto fail;
1853
                    }
1854
                }
1855
                if (ost->video_resample) {
1856
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1857
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1858
                                         codec->width, codec->height)) {
1859
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1860
                        av_exit(1);
1861
                    }
1862
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1863
                    ost->img_resample_ctx = sws_getContext(
1864
                            icodec->width - (frame_leftBand + frame_rightBand),
1865
                            icodec->height - (frame_topBand + frame_bottomBand),
1866
                            icodec->pix_fmt,
1867
                            codec->width - (frame_padleft + frame_padright),
1868
                            codec->height - (frame_padtop + frame_padbottom),
1869
                            codec->pix_fmt,
1870
                            sws_flags, NULL, NULL, NULL);
1871
                    if (ost->img_resample_ctx == NULL) {
1872
                        fprintf(stderr, "Cannot get resampling context\n");
1873
                        av_exit(1);
1874
                    }
1875
                    ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1876
                    codec->bits_per_raw_sample= 0;
1877
                }
1878
                ost->encoding_needed = 1;
1879
                ist->decoding_needed = 1;
1880
                break;
1881
            case CODEC_TYPE_SUBTITLE:
1882
                ost->encoding_needed = 1;
1883
                ist->decoding_needed = 1;
1884
                break;
1885
            default:
1886
                abort();
1887
                break;
1888
            }
1889
            /* two pass mode */
1890
            if (ost->encoding_needed &&
1891
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1892
                char logfilename[1024];
1893
                FILE *f;
1894
                int size;
1895
                char *logbuffer;
1896

    
1897
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1898
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1899
                         i);
1900
                if (codec->flags & CODEC_FLAG_PASS1) {
1901
                    f = fopen(logfilename, "w");
1902
                    if (!f) {
1903
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1904
                        av_exit(1);
1905
                    }
1906
                    ost->logfile = f;
1907
                } else {
1908
                    /* read the log file */
1909
                    f = fopen(logfilename, "r");
1910
                    if (!f) {
1911
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1912
                        av_exit(1);
1913
                    }
1914
                    fseek(f, 0, SEEK_END);
1915
                    size = ftell(f);
1916
                    fseek(f, 0, SEEK_SET);
1917
                    logbuffer = av_malloc(size + 1);
1918
                    if (!logbuffer) {
1919
                        fprintf(stderr, "Could not allocate log buffer\n");
1920
                        av_exit(1);
1921
                    }
1922
                    size = fread(logbuffer, 1, size, f);
1923
                    fclose(f);
1924
                    logbuffer[size] = '\0';
1925
                    codec->stats_in = logbuffer;
1926
                }
1927
            }
1928
        }
1929
        if(codec->codec_type == CODEC_TYPE_VIDEO){
1930
            int size= codec->width * codec->height;
1931
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1932
        }
1933
    }
1934

    
1935
    if (!bit_buffer)
1936
        bit_buffer = av_malloc(bit_buffer_size);
1937
    if (!bit_buffer) {
1938
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
1939
                bit_buffer_size);
1940
        ret = AVERROR(ENOMEM);
1941
        goto fail;
1942
    }
1943

    
1944
    /* open each encoder */
1945
    for(i=0;i<nb_ostreams;i++) {
1946
        ost = ost_table[i];
1947
        if (ost->encoding_needed) {
1948
            AVCodec *codec = output_codecs[i];
1949
            if (!codec)
1950
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
1951
            if (!codec) {
1952
                snprintf(error, sizeof(error), "Unsupported codec for output stream #%d.%d",
1953
                        ost->file_index, ost->index);
1954
                ret = AVERROR(EINVAL);
1955
                goto dump_format;
1956
            }
1957
            if (avcodec_open(ost->st->codec, codec) < 0) {
1958
                snprintf(error, sizeof(error), "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1959
                        ost->file_index, ost->index);
1960
                ret = AVERROR(EINVAL);
1961
                goto dump_format;
1962
            }
1963
            extra_size += ost->st->codec->extradata_size;
1964
        }
1965
    }
1966

    
1967
    /* open each decoder */
1968
    for(i=0;i<nb_istreams;i++) {
1969
        ist = ist_table[i];
1970
        if (ist->decoding_needed) {
1971
            AVCodec *codec = input_codecs[i];
1972
            if (!codec)
1973
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
1974
            if (!codec) {
1975
                snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
1976
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1977
                ret = AVERROR(EINVAL);
1978
                goto dump_format;
1979
            }
1980
            if (avcodec_open(ist->st->codec, codec) < 0) {
1981
                snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
1982
                        ist->file_index, ist->index);
1983
                ret = AVERROR(EINVAL);
1984
                goto dump_format;
1985
            }
1986
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1987
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1988
        }
1989
    }
1990

    
1991
    /* init pts */
1992
    for(i=0;i<nb_istreams;i++) {
1993
        ist = ist_table[i];
1994
        ist->pts = 0;
1995
        ist->next_pts = AV_NOPTS_VALUE;
1996
        ist->is_start = 1;
1997
    }
1998

    
1999
    /* set meta data information from input file if required */
2000
    for (i=0;i<nb_meta_data_maps;i++) {
2001
        AVFormatContext *out_file;
2002
        AVFormatContext *in_file;
2003
        AVMetadataTag *mtag;
2004

    
2005
        int out_file_index = meta_data_maps[i].out_file;
2006
        int in_file_index = meta_data_maps[i].in_file;
2007
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2008
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2009
                     out_file_index, out_file_index, in_file_index);
2010
            ret = AVERROR(EINVAL);
2011
            goto dump_format;
2012
        }
2013
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2014
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2015
                     in_file_index, out_file_index, in_file_index);
2016
            ret = AVERROR(EINVAL);
2017
            goto dump_format;
2018
        }
2019

    
2020
        out_file = output_files[out_file_index];
2021
        in_file = input_files[in_file_index];
2022

    
2023

    
2024
        mtag=NULL;
2025
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2026
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2027
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2028
                                    in_file->iformat->metadata_conv);
2029
    }
2030

    
2031
    /* open files and write file headers */
2032
    for(i=0;i<nb_output_files;i++) {
2033
        os = output_files[i];
2034
        if (av_write_header(os) < 0) {
2035
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2036
            ret = AVERROR(EINVAL);
2037
            goto dump_format;
2038
        }
2039
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2040
            want_sdp = 0;
2041
        }
2042
    }
2043

    
2044
 dump_format:
2045
    /* dump the file output parameters - cannot be done before in case
2046
       of stream copy */
2047
    for(i=0;i<nb_output_files;i++) {
2048
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2049
    }
2050

    
2051
    /* dump the stream mapping */
2052
    if (verbose >= 0) {
2053
        fprintf(stderr, "Stream mapping:\n");
2054
        for(i=0;i<nb_ostreams;i++) {
2055
            ost = ost_table[i];
2056
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2057
                    ist_table[ost->source_index]->file_index,
2058
                    ist_table[ost->source_index]->index,
2059
                    ost->file_index,
2060
                    ost->index);
2061
            if (ost->sync_ist != ist_table[ost->source_index])
2062
                fprintf(stderr, " [sync #%d.%d]",
2063
                        ost->sync_ist->file_index,
2064
                        ost->sync_ist->index);
2065
            fprintf(stderr, "\n");
2066
        }
2067
    }
2068

    
2069
    if (ret) {
2070
        fprintf(stderr, "%s\n", error);
2071
        goto fail;
2072
    }
2073

    
2074
    if (want_sdp) {
2075
        print_sdp(output_files, nb_output_files);
2076
    }
2077

    
2078
    if (!using_stdin && verbose >= 0) {
2079
        fprintf(stderr, "Press [q] to stop encoding\n");
2080
        url_set_interrupt_cb(decode_interrupt_cb);
2081
    }
2082
    term_init();
2083

    
2084
    timer_start = av_gettime();
2085

    
2086
    for(; received_sigterm == 0;) {
2087
        int file_index, ist_index;
2088
        AVPacket pkt;
2089
        double ipts_min;
2090
        double opts_min;
2091

    
2092
    redo:
2093
        ipts_min= 1e100;
2094
        opts_min= 1e100;
2095
        /* if 'q' pressed, exits */
2096
        if (!using_stdin) {
2097
            if (q_pressed)
2098
                break;
2099
            /* read_key() returns 0 on EOF */
2100
            key = read_key();
2101
            if (key == 'q')
2102
                break;
2103
        }
2104

    
2105
        /* select the stream that we must read now by looking at the
2106
           smallest output pts */
2107
        file_index = -1;
2108
        for(i=0;i<nb_ostreams;i++) {
2109
            double ipts, opts;
2110
            ost = ost_table[i];
2111
            os = output_files[ost->file_index];
2112
            ist = ist_table[ost->source_index];
2113
            if(no_packet[ist->file_index])
2114
                continue;
2115
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2116
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2117
            else
2118
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2119
            ipts = (double)ist->pts;
2120
            if (!file_table[ist->file_index].eof_reached){
2121
                if(ipts < ipts_min) {
2122
                    ipts_min = ipts;
2123
                    if(input_sync ) file_index = ist->file_index;
2124
                }
2125
                if(opts < opts_min) {
2126
                    opts_min = opts;
2127
                    if(!input_sync) file_index = ist->file_index;
2128
                }
2129
            }
2130
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2131
                file_index= -1;
2132
                break;
2133
            }
2134
        }
2135
        /* if none, if is finished */
2136
        if (file_index < 0) {
2137
            if(no_packet_count){
2138
                no_packet_count=0;
2139
                memset(no_packet, 0, sizeof(no_packet));
2140
                usleep(10000);
2141
                continue;
2142
            }
2143
            break;
2144
        }
2145

    
2146
        /* finish if recording time exhausted */
2147
        if (opts_min >= (recording_time / 1000000.0))
2148
            break;
2149

    
2150
        /* finish if limit size exhausted */
2151
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2152
            break;
2153

    
2154
        /* read a frame from it and output it in the fifo */
2155
        is = input_files[file_index];
2156
        ret= av_read_frame(is, &pkt);
2157
        if(ret == AVERROR(EAGAIN)){
2158
            no_packet[file_index]=1;
2159
            no_packet_count++;
2160
            continue;
2161
        }
2162
        if (ret < 0) {
2163
            file_table[file_index].eof_reached = 1;
2164
            if (opt_shortest)
2165
                break;
2166
            else
2167
                continue;
2168
        }
2169

    
2170
        no_packet_count=0;
2171
        memset(no_packet, 0, sizeof(no_packet));
2172

    
2173
        if (do_pkt_dump) {
2174
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2175
        }
2176
        /* the following test is needed in case new streams appear
2177
           dynamically in stream : we ignore them */
2178
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2179
            goto discard_packet;
2180
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2181
        ist = ist_table[ist_index];
2182
        if (ist->discard)
2183
            goto discard_packet;
2184

    
2185
        if (pkt.dts != AV_NOPTS_VALUE)
2186
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2187
        if (pkt.pts != AV_NOPTS_VALUE)
2188
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2189

    
2190
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2191
            if(pkt.pts != AV_NOPTS_VALUE)
2192
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2193
            if(pkt.dts != AV_NOPTS_VALUE)
2194
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2195
        }
2196

    
2197
//        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);
2198
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2199
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2200
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2201
            int64_t delta= pkt_dts - ist->next_pts;
2202
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2203
                input_files_ts_offset[ist->file_index]-= delta;
2204
                if (verbose > 2)
2205
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2206
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2207
                if(pkt.pts != AV_NOPTS_VALUE)
2208
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2209
            }
2210
        }
2211

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

    
2215
            if (verbose >= 0)
2216
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2217
                        ist->file_index, ist->index);
2218
            if (exit_on_error)
2219
                av_exit(1);
2220
            av_free_packet(&pkt);
2221
            goto redo;
2222
        }
2223

    
2224
    discard_packet:
2225
        av_free_packet(&pkt);
2226

    
2227
        /* dump report by using the output first video and audio streams */
2228
        print_report(output_files, ost_table, nb_ostreams, 0);
2229
    }
2230

    
2231
    /* at the end of stream, we must flush the decoder buffers */
2232
    for(i=0;i<nb_istreams;i++) {
2233
        ist = ist_table[i];
2234
        if (ist->decoding_needed) {
2235
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2236
        }
2237
    }
2238

    
2239
    term_exit();
2240

    
2241
    /* write the trailer if needed and close file */
2242
    for(i=0;i<nb_output_files;i++) {
2243
        os = output_files[i];
2244
        av_write_trailer(os);
2245
    }
2246

    
2247
    /* dump report by using the first video and audio streams */
2248
    print_report(output_files, ost_table, nb_ostreams, 1);
2249

    
2250
    /* close each encoder */
2251
    for(i=0;i<nb_ostreams;i++) {
2252
        ost = ost_table[i];
2253
        if (ost->encoding_needed) {
2254
            av_freep(&ost->st->codec->stats_in);
2255
            avcodec_close(ost->st->codec);
2256
        }
2257
    }
2258

    
2259
    /* close each decoder */
2260
    for(i=0;i<nb_istreams;i++) {
2261
        ist = ist_table[i];
2262
        if (ist->decoding_needed) {
2263
            avcodec_close(ist->st->codec);
2264
        }
2265
    }
2266

    
2267
    /* finished ! */
2268
    ret = 0;
2269

    
2270
 fail:
2271
    av_freep(&bit_buffer);
2272
    av_free(file_table);
2273

    
2274
    if (ist_table) {
2275
        for(i=0;i<nb_istreams;i++) {
2276
            ist = ist_table[i];
2277
            av_free(ist);
2278
        }
2279
        av_free(ist_table);
2280
    }
2281
    if (ost_table) {
2282
        for(i=0;i<nb_ostreams;i++) {
2283
            ost = ost_table[i];
2284
            if (ost) {
2285
                if (ost->logfile) {
2286
                    fclose(ost->logfile);
2287
                    ost->logfile = NULL;
2288
                }
2289
                av_fifo_free(ost->fifo); /* works even if fifo is not
2290
                                             initialized but set to zero */
2291
                av_free(ost->pict_tmp.data[0]);
2292
                if (ost->video_resample)
2293
                    sws_freeContext(ost->img_resample_ctx);
2294
                if (ost->resample)
2295
                    audio_resample_close(ost->resample);
2296
                if (ost->reformat_ctx)
2297
                    av_audio_convert_free(ost->reformat_ctx);
2298
                av_free(ost);
2299
            }
2300
        }
2301
        av_free(ost_table);
2302
    }
2303
    return ret;
2304
}
2305

    
2306
#if 0
2307
int file_read(const char *filename)
2308
{
2309
    URLContext *h;
2310
    unsigned char buffer[1024];
2311
    int len, i;
2312

2313
    if (url_open(&h, filename, O_RDONLY) < 0) {
2314
        printf("could not open '%s'\n", filename);
2315
        return -1;
2316
    }
2317
    for(;;) {
2318
        len = url_read(h, buffer, sizeof(buffer));
2319
        if (len <= 0)
2320
            break;
2321
        for(i=0;i<len;i++) putchar(buffer[i]);
2322
    }
2323
    url_close(h);
2324
    return 0;
2325
}
2326
#endif
2327

    
2328
static void opt_format(const char *arg)
2329
{
2330
    /* compatibility stuff for pgmyuv */
2331
    if (!strcmp(arg, "pgmyuv")) {
2332
        pgmyuv_compatibility_hack=1;
2333
//        opt_image_format(arg);
2334
        arg = "image2";
2335
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2336
    }
2337

    
2338
    file_iformat = av_find_input_format(arg);
2339
    file_oformat = guess_format(arg, NULL, NULL);
2340
    if (!file_iformat && !file_oformat) {
2341
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2342
        av_exit(1);
2343
    }
2344
}
2345

    
2346
static void opt_video_rc_override_string(const char *arg)
2347
{
2348
    video_rc_override_string = arg;
2349
}
2350

    
2351
static int opt_me_threshold(const char *opt, const char *arg)
2352
{
2353
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2354
    return 0;
2355
}
2356

    
2357
static int opt_verbose(const char *opt, const char *arg)
2358
{
2359
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2360
    return 0;
2361
}
2362

    
2363
static int opt_frame_rate(const char *opt, const char *arg)
2364
{
2365
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2366
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2367
        av_exit(1);
2368
    }
2369
    return 0;
2370
}
2371

    
2372
static int opt_bitrate(const char *opt, const char *arg)
2373
{
2374
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2375

    
2376
    opt_default(opt, arg);
2377

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

    
2381
    return 0;
2382
}
2383

    
2384
static void opt_frame_crop_top(const char *arg)
2385
{
2386
    frame_topBand = atoi(arg);
2387
    if (frame_topBand < 0) {
2388
        fprintf(stderr, "Incorrect top crop size\n");
2389
        av_exit(1);
2390
    }
2391
    if ((frame_topBand) >= frame_height){
2392
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2393
        av_exit(1);
2394
    }
2395
    frame_height -= frame_topBand;
2396
}
2397

    
2398
static void opt_frame_crop_bottom(const char *arg)
2399
{
2400
    frame_bottomBand = atoi(arg);
2401
    if (frame_bottomBand < 0) {
2402
        fprintf(stderr, "Incorrect bottom crop size\n");
2403
        av_exit(1);
2404
    }
2405
    if ((frame_bottomBand) >= frame_height){
2406
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2407
        av_exit(1);
2408
    }
2409
    frame_height -= frame_bottomBand;
2410
}
2411

    
2412
static void opt_frame_crop_left(const char *arg)
2413
{
2414
    frame_leftBand = atoi(arg);
2415
    if (frame_leftBand < 0) {
2416
        fprintf(stderr, "Incorrect left crop size\n");
2417
        av_exit(1);
2418
    }
2419
    if ((frame_leftBand) >= frame_width){
2420
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2421
        av_exit(1);
2422
    }
2423
    frame_width -= frame_leftBand;
2424
}
2425

    
2426
static void opt_frame_crop_right(const char *arg)
2427
{
2428
    frame_rightBand = atoi(arg);
2429
    if (frame_rightBand < 0) {
2430
        fprintf(stderr, "Incorrect right crop size\n");
2431
        av_exit(1);
2432
    }
2433
    if ((frame_rightBand) >= frame_width){
2434
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2435
        av_exit(1);
2436
    }
2437
    frame_width -= frame_rightBand;
2438
}
2439

    
2440
static void opt_frame_size(const char *arg)
2441
{
2442
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2443
        fprintf(stderr, "Incorrect frame size\n");
2444
        av_exit(1);
2445
    }
2446
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2447
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2448
        av_exit(1);
2449
    }
2450
}
2451

    
2452
static void opt_pad_color(const char *arg) {
2453
    /* Input is expected to be six hex digits similar to
2454
       how colors are expressed in html tags (but without the #) */
2455
    int rgb = strtol(arg, NULL, 16);
2456
    int r,g,b;
2457

    
2458
    r = (rgb >> 16);
2459
    g = ((rgb >> 8) & 255);
2460
    b = (rgb & 255);
2461

    
2462
    padcolor[0] = RGB_TO_Y(r,g,b);
2463
    padcolor[1] = RGB_TO_U(r,g,b,0);
2464
    padcolor[2] = RGB_TO_V(r,g,b,0);
2465
}
2466

    
2467
static void opt_frame_pad_top(const char *arg)
2468
{
2469
    frame_padtop = atoi(arg);
2470
    if (frame_padtop < 0) {
2471
        fprintf(stderr, "Incorrect top pad size\n");
2472
        av_exit(1);
2473
    }
2474
}
2475

    
2476
static void opt_frame_pad_bottom(const char *arg)
2477
{
2478
    frame_padbottom = atoi(arg);
2479
    if (frame_padbottom < 0) {
2480
        fprintf(stderr, "Incorrect bottom pad size\n");
2481
        av_exit(1);
2482
    }
2483
}
2484

    
2485

    
2486
static void opt_frame_pad_left(const char *arg)
2487
{
2488
    frame_padleft = atoi(arg);
2489
    if (frame_padleft < 0) {
2490
        fprintf(stderr, "Incorrect left pad size\n");
2491
        av_exit(1);
2492
    }
2493
}
2494

    
2495

    
2496
static void opt_frame_pad_right(const char *arg)
2497
{
2498
    frame_padright = atoi(arg);
2499
    if (frame_padright < 0) {
2500
        fprintf(stderr, "Incorrect right pad size\n");
2501
        av_exit(1);
2502
    }
2503
}
2504

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

    
2515
static void opt_frame_pix_fmt(const char *arg)
2516
{
2517
    if (strcmp(arg, "list")) {
2518
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2519
        if (frame_pix_fmt == PIX_FMT_NONE) {
2520
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2521
            av_exit(1);
2522
        }
2523
    } else {
2524
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2525
        av_exit(0);
2526
    }
2527
}
2528

    
2529
static void opt_frame_aspect_ratio(const char *arg)
2530
{
2531
    int x = 0, y = 0;
2532
    double ar = 0;
2533
    const char *p;
2534
    char *end;
2535

    
2536
    p = strchr(arg, ':');
2537
    if (p) {
2538
        x = strtol(arg, &end, 10);
2539
        if (end == p)
2540
            y = strtol(end+1, &end, 10);
2541
        if (x > 0 && y > 0)
2542
            ar = (double)x / (double)y;
2543
    } else
2544
        ar = strtod(arg, NULL);
2545

    
2546
    if (!ar) {
2547
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2548
        av_exit(1);
2549
    }
2550
    frame_aspect_ratio = ar;
2551
}
2552

    
2553
static int opt_metadata(const char *opt, const char *arg)
2554
{
2555
    char *mid= strchr(arg, '=');
2556

    
2557
    if(!mid){
2558
        fprintf(stderr, "Missing =\n");
2559
        av_exit(1);
2560
    }
2561
    *mid++= 0;
2562

    
2563
    metadata_count++;
2564
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2565
    metadata[metadata_count-1].key  = av_strdup(arg);
2566
    metadata[metadata_count-1].value= av_strdup(mid);
2567

    
2568
    return 0;
2569
}
2570

    
2571
static void opt_qscale(const char *arg)
2572
{
2573
    video_qscale = atof(arg);
2574
    if (video_qscale <= 0 ||
2575
        video_qscale > 255) {
2576
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2577
        av_exit(1);
2578
    }
2579
}
2580

    
2581
static void opt_top_field_first(const char *arg)
2582
{
2583
    top_field_first= atoi(arg);
2584
}
2585

    
2586
static int opt_thread_count(const char *opt, const char *arg)
2587
{
2588
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2589
#if !HAVE_THREADS
2590
    if (verbose >= 0)
2591
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2592
#endif
2593
    return 0;
2594
}
2595

    
2596
static void opt_audio_sample_fmt(const char *arg)
2597
{
2598
    if (strcmp(arg, "list"))
2599
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2600
    else {
2601
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2602
        av_exit(0);
2603
    }
2604
}
2605

    
2606
static int opt_audio_rate(const char *opt, const char *arg)
2607
{
2608
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2609
    return 0;
2610
}
2611

    
2612
static int opt_audio_channels(const char *opt, const char *arg)
2613
{
2614
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2615
    return 0;
2616
}
2617

    
2618
static void opt_video_channel(const char *arg)
2619
{
2620
    video_channel = strtol(arg, NULL, 0);
2621
}
2622

    
2623
static void opt_video_standard(const char *arg)
2624
{
2625
    video_standard = av_strdup(arg);
2626
}
2627

    
2628
static void opt_codec(int *pstream_copy, char **pcodec_name,
2629
                      int codec_type, const char *arg)
2630
{
2631
    av_freep(pcodec_name);
2632
    if (!strcmp(arg, "copy")) {
2633
        *pstream_copy = 1;
2634
    } else {
2635
        *pcodec_name = av_strdup(arg);
2636
    }
2637
}
2638

    
2639
static void opt_audio_codec(const char *arg)
2640
{
2641
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2642
}
2643

    
2644
static void opt_audio_tag(const char *arg)
2645
{
2646
    char *tail;
2647
    audio_codec_tag= strtol(arg, &tail, 0);
2648

    
2649
    if(!tail || *tail)
2650
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2651
}
2652

    
2653
static void opt_video_tag(const char *arg)
2654
{
2655
    char *tail;
2656
    video_codec_tag= strtol(arg, &tail, 0);
2657

    
2658
    if(!tail || *tail)
2659
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2660
}
2661

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

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

    
2672
static void opt_subtitle_tag(const char *arg)
2673
{
2674
    char *tail;
2675
    subtitle_codec_tag= strtol(arg, &tail, 0);
2676

    
2677
    if(!tail || *tail)
2678
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2679
}
2680

    
2681
static void opt_map(const char *arg)
2682
{
2683
    AVStreamMap *m;
2684
    char *p;
2685

    
2686
    m = &stream_maps[nb_stream_maps++];
2687

    
2688
    m->file_index = strtol(arg, &p, 0);
2689
    if (*p)
2690
        p++;
2691

    
2692
    m->stream_index = strtol(p, &p, 0);
2693
    if (*p) {
2694
        p++;
2695
        m->sync_file_index = strtol(p, &p, 0);
2696
        if (*p)
2697
            p++;
2698
        m->sync_stream_index = strtol(p, &p, 0);
2699
    } else {
2700
        m->sync_file_index = m->file_index;
2701
        m->sync_stream_index = m->stream_index;
2702
    }
2703
}
2704

    
2705
static void opt_map_meta_data(const char *arg)
2706
{
2707
    AVMetaDataMap *m;
2708
    char *p;
2709

    
2710
    m = &meta_data_maps[nb_meta_data_maps++];
2711

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

    
2716
    m->in_file = strtol(p, &p, 0);
2717
}
2718

    
2719
static void opt_input_ts_scale(const char *arg)
2720
{
2721
    unsigned int stream;
2722
    double scale;
2723
    char *p;
2724

    
2725
    stream = strtol(arg, &p, 0);
2726
    if (*p)
2727
        p++;
2728
    scale= strtod(p, &p);
2729

    
2730
    if(stream >= MAX_STREAMS)
2731
        av_exit(1);
2732

    
2733
    input_files_ts_scale[nb_input_files][stream]= scale;
2734
}
2735

    
2736
static int opt_recording_time(const char *opt, const char *arg)
2737
{
2738
    recording_time = parse_time_or_die(opt, arg, 1);
2739
    return 0;
2740
}
2741

    
2742
static int opt_start_time(const char *opt, const char *arg)
2743
{
2744
    start_time = parse_time_or_die(opt, arg, 1);
2745
    return 0;
2746
}
2747

    
2748
static int opt_rec_timestamp(const char *opt, const char *arg)
2749
{
2750
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2751
    return 0;
2752
}
2753

    
2754
static int opt_input_ts_offset(const char *opt, const char *arg)
2755
{
2756
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2757
    return 0;
2758
}
2759

    
2760
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2761
{
2762
    const char *codec_string = encoder ? "encoder" : "decoder";
2763
    AVCodec *codec;
2764

    
2765
    if(!name)
2766
        return CODEC_ID_NONE;
2767
    codec = encoder ?
2768
        avcodec_find_encoder_by_name(name) :
2769
        avcodec_find_decoder_by_name(name);
2770
    if(!codec) {
2771
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2772
        av_exit(1);
2773
    }
2774
    if(codec->type != type) {
2775
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2776
        av_exit(1);
2777
    }
2778
    return codec->id;
2779
}
2780

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

    
2788
    if (!strcmp(filename, "-"))
2789
        filename = "pipe:";
2790

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

    
2794
    /* get default parameters from command line */
2795
    ic = avformat_alloc_context();
2796

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

    
2814
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2815

    
2816
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2817
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2818
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2819
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2820

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

    
2834
    ic->loop_input = loop_input;
2835

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

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

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

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

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

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

    
2900
                    (float)rfps / rfps_base, rfps, rfps_base);
2901
            }
2902
            /* update the current frame rate to match the stream frame rate */
2903
            frame_rate.num = rfps;
2904
            frame_rate.den = rfps_base;
2905

    
2906
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2907
            if(video_disable)
2908
                ic->streams[i]->discard= AVDISCARD_ALL;
2909
            else if(video_discard)
2910
                ic->streams[i]->discard= video_discard;
2911
            break;
2912
        case CODEC_TYPE_DATA:
2913
            break;
2914
        case CODEC_TYPE_SUBTITLE:
2915
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2916
            if(subtitle_disable)
2917
                ic->streams[i]->discard = AVDISCARD_ALL;
2918
            break;
2919
        case CODEC_TYPE_ATTACHMENT:
2920
        case CODEC_TYPE_UNKNOWN:
2921
            nb_icodecs++;
2922
            break;
2923
        default:
2924
            abort();
2925
        }
2926
    }
2927

    
2928
    input_files[nb_input_files] = ic;
2929
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2930
    /* dump the file content */
2931
    if (verbose >= 0)
2932
        dump_format(ic, nb_input_files, filename, 0);
2933

    
2934
    nb_input_files++;
2935
    file_iformat = NULL;
2936
    file_oformat = NULL;
2937

    
2938
    video_channel = 0;
2939

    
2940
    av_freep(&video_codec_name);
2941
    av_freep(&audio_codec_name);
2942
    av_freep(&subtitle_codec_name);
2943
}
2944

    
2945
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2946
                                         int *has_subtitle_ptr)
2947
{
2948
    int has_video, has_audio, has_subtitle, i, j;
2949
    AVFormatContext *ic;
2950

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

    
2982
static void new_video_stream(AVFormatContext *oc)
2983
{
2984
    AVStream *st;
2985
    AVCodecContext *video_enc;
2986
    int codec_id;
2987

    
2988
    st = av_new_stream(oc, oc->nb_streams);
2989
    if (!st) {
2990
        fprintf(stderr, "Could not alloc stream\n");
2991
        av_exit(1);
2992
    }
2993
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2994
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2995
    video_bitstream_filters= NULL;
2996

    
2997
    if(thread_count>1)
2998
        avcodec_thread_init(st->codec, thread_count);
2999

    
3000
    video_enc = st->codec;
3001

    
3002
    if(video_codec_tag)
3003
        video_enc->codec_tag= video_codec_tag;
3004

    
3005
    if(   (video_global_header&1)
3006
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3007
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3008
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3009
    }
3010
    if(video_global_header&2){
3011
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3012
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3013
    }
3014

    
3015
    if (video_stream_copy) {
3016
        st->stream_copy = 1;
3017
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3018
        video_enc->sample_aspect_ratio =
3019
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3020
    } else {
3021
        const char *p;
3022
        int i;
3023
        AVCodec *codec;
3024
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3025

    
3026
        if (video_codec_name) {
3027
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3028
            codec = avcodec_find_encoder_by_name(video_codec_name);
3029
            output_codecs[nb_ocodecs] = codec;
3030
        } else {
3031
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3032
            codec = avcodec_find_encoder(codec_id);
3033
        }
3034

    
3035
        video_enc->codec_id = codec_id;
3036

    
3037
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3038

    
3039
        if (codec && codec->supported_framerates && !force_fps)
3040
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3041
        video_enc->time_base.den = fps.num;
3042
        video_enc->time_base.num = fps.den;
3043

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3161
        if (audio_codec_name) {
3162
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3163
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3164
            output_codecs[nb_ocodecs] = codec;
3165
        } else {
3166
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3167
            codec = avcodec_find_encoder(codec_id);
3168
        }
3169
        audio_enc->codec_id = codec_id;
3170

    
3171
        if (audio_qscale > QSCALE_NONE) {
3172
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3173
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3174
        }
3175
        audio_enc->thread_count = thread_count;
3176
        audio_enc->channels = audio_channels;
3177
        audio_enc->sample_fmt = audio_sample_fmt;
3178
        audio_enc->channel_layout = channel_layout;
3179
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3180
            audio_enc->channel_layout = 0;
3181

    
3182
        if(codec && codec->sample_fmts){
3183
            const enum SampleFormat *p= codec->sample_fmts;
3184
            for(; *p!=-1; p++){
3185
                if(*p == audio_enc->sample_fmt)
3186
                    break;
3187
            }
3188
            if(*p == -1)
3189
                audio_enc->sample_fmt = codec->sample_fmts[0];
3190
        }
3191
    }
3192
    nb_ocodecs++;
3193
    audio_enc->sample_rate = audio_sample_rate;
3194
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3195
    if (audio_language) {
3196
        av_metadata_set(&st->metadata, "language", audio_language);
3197
        av_free(audio_language);
3198
        audio_language = NULL;
3199
    }
3200

    
3201
    /* reset some key parameters */
3202
    audio_disable = 0;
3203
    av_freep(&audio_codec_name);
3204
    audio_stream_copy = 0;
3205
}
3206

    
3207
static void new_subtitle_stream(AVFormatContext *oc)
3208
{
3209
    AVStream *st;
3210
    AVCodecContext *subtitle_enc;
3211

    
3212
    st = av_new_stream(oc, oc->nb_streams);
3213
    if (!st) {
3214
        fprintf(stderr, "Could not alloc stream\n");
3215
        av_exit(1);
3216
    }
3217
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3218

    
3219
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3220
    subtitle_bitstream_filters= NULL;
3221

    
3222
    subtitle_enc = st->codec;
3223
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3224

    
3225
    if(subtitle_codec_tag)
3226
        subtitle_enc->codec_tag= subtitle_codec_tag;
3227

    
3228
    if (subtitle_stream_copy) {
3229
        st->stream_copy = 1;
3230
    } else {
3231
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3232
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3233
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3234
    }
3235
    nb_ocodecs++;
3236

    
3237
    if (subtitle_language) {
3238
        av_metadata_set(&st->metadata, "language", subtitle_language);
3239
        av_free(subtitle_language);
3240
        subtitle_language = NULL;
3241
    }
3242

    
3243
    subtitle_disable = 0;
3244
    av_freep(&subtitle_codec_name);
3245
    subtitle_stream_copy = 0;
3246
}
3247

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

    
3259
static void opt_new_video_stream(void)
3260
{
3261
    AVFormatContext *oc;
3262
    if (nb_output_files <= 0) {
3263
        fprintf(stderr, "At least one output file must be specified\n");
3264
        av_exit(1);
3265
    }
3266
    oc = output_files[nb_output_files - 1];
3267
    new_video_stream(oc);
3268
}
3269

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

    
3281
static void opt_output_file(const char *filename)
3282
{
3283
    AVFormatContext *oc;
3284
    int use_video, use_audio, use_subtitle;
3285
    int input_has_video, input_has_audio, input_has_subtitle;
3286
    AVFormatParameters params, *ap = &params;
3287

    
3288
    if (!strcmp(filename, "-"))
3289
        filename = "pipe:";
3290

    
3291
    oc = avformat_alloc_context();
3292

    
3293
    if (!file_oformat) {
3294
        file_oformat = guess_format(NULL, filename, NULL);
3295
        if (!file_oformat) {
3296
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3297
                    filename);
3298
            av_exit(1);
3299
        }
3300
    }
3301

    
3302
    oc->oformat = file_oformat;
3303
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3304

    
3305
    if (!strcmp(file_oformat->name, "ffm") &&
3306
        av_strstart(filename, "http:", NULL)) {
3307
        /* special case for files sent to ffserver: we get the stream
3308
           parameters from ffserver */
3309
        int err = read_ffserver_streams(oc, filename);
3310
        if (err < 0) {
3311
            print_error(filename, err);
3312
            av_exit(1);
3313
        }
3314
    } else {
3315
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3316
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3317
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3318

    
3319
        /* disable if no corresponding type found and at least one
3320
           input file */
3321
        if (nb_input_files > 0) {
3322
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3323
                                         &input_has_subtitle);
3324
            if (!input_has_video)
3325
                use_video = 0;
3326
            if (!input_has_audio)
3327
                use_audio = 0;
3328
            if (!input_has_subtitle)
3329
                use_subtitle = 0;
3330
        }
3331

    
3332
        /* manual disable */
3333
        if (audio_disable) {
3334
            use_audio = 0;
3335
        }
3336
        if (video_disable) {
3337
            use_video = 0;
3338
        }
3339
        if (subtitle_disable) {
3340
            use_subtitle = 0;
3341
        }
3342

    
3343
        if (use_video) {
3344
            new_video_stream(oc);
3345
        }
3346

    
3347
        if (use_audio) {
3348
            new_audio_stream(oc);
3349
        }
3350

    
3351
        if (use_subtitle) {
3352
            new_subtitle_stream(oc);
3353
        }
3354

    
3355
        oc->timestamp = rec_timestamp;
3356

    
3357
        for(; metadata_count>0; metadata_count--){
3358
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3359
                                           metadata[metadata_count-1].value);
3360
        }
3361
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3362
    }
3363

    
3364
    output_files[nb_output_files++] = oc;
3365

    
3366
    /* check filename in case of an image number is expected */
3367
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3368
        if (!av_filename_number_test(oc->filename)) {
3369
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3370
            av_exit(1);
3371
        }
3372
    }
3373

    
3374
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3375
        /* test if it already exists to avoid loosing precious files */
3376
        if (!file_overwrite &&
3377
            (strchr(filename, ':') == NULL ||
3378
             filename[1] == ':' ||
3379
             av_strstart(filename, "file:", NULL))) {
3380
            if (url_exist(filename)) {
3381
                if (!using_stdin) {
3382
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3383
                    fflush(stderr);
3384
                    if (!read_yesno()) {
3385
                        fprintf(stderr, "Not overwriting - exiting\n");
3386
                        av_exit(1);
3387
                    }
3388
                }
3389
                else {
3390
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3391
                    av_exit(1);
3392
                }
3393
            }
3394
        }
3395

    
3396
        /* open the file */
3397
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3398
            fprintf(stderr, "Could not open '%s'\n", filename);
3399
            av_exit(1);
3400
        }
3401
    }
3402

    
3403
    memset(ap, 0, sizeof(*ap));
3404
    if (av_set_parameters(oc, ap) < 0) {
3405
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3406
                oc->filename);
3407
        av_exit(1);
3408
    }
3409

    
3410
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3411
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3412
    oc->loop_output = loop_output;
3413
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3414

    
3415
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3416

    
3417
    /* reset some options */
3418
    file_oformat = NULL;
3419
    file_iformat = NULL;
3420
}
3421

    
3422
/* same option as mencoder */
3423
static void opt_pass(const char *pass_str)
3424
{
3425
    int pass;
3426
    pass = atoi(pass_str);
3427
    if (pass != 1 && pass != 2) {
3428
        fprintf(stderr, "pass number can be only 1 or 2\n");
3429
        av_exit(1);
3430
    }
3431
    do_pass = pass;
3432
}
3433

    
3434
static int64_t getutime(void)
3435
{
3436
#if HAVE_GETRUSAGE
3437
    struct rusage rusage;
3438

    
3439
    getrusage(RUSAGE_SELF, &rusage);
3440
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3441
#elif HAVE_GETPROCESSTIMES
3442
    HANDLE proc;
3443
    FILETIME c, e, k, u;
3444
    proc = GetCurrentProcess();
3445
    GetProcessTimes(proc, &c, &e, &k, &u);
3446
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3447
#else
3448
    return av_gettime();
3449
#endif
3450
}
3451

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

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

    
3475
static void opt_intra_matrix(const char *arg)
3476
{
3477
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3478
    parse_matrix_coeffs(intra_matrix, arg);
3479
}
3480

    
3481
/**
3482
 * Trivial log callback.
3483
 * Only suitable for show_help and similar since it lacks prefix handling.
3484
 */
3485
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3486
{
3487
    vfprintf(stdout, fmt, vl);
3488
}
3489

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

    
3527
static void opt_target(const char *arg)
3528
{
3529
    int norm = -1;
3530
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3531

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

    
3576
    if(norm < 0) {
3577
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3578
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3579
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3580
        av_exit(1);
3581
    }
3582

    
3583
    if(!strcmp(arg, "vcd")) {
3584

    
3585
        opt_video_codec("mpeg1video");
3586
        opt_audio_codec("mp2");
3587
        opt_format("vcd");
3588

    
3589
        opt_frame_size(norm ? "352x240" : "352x288");
3590
        opt_frame_rate(NULL, frame_rates[norm]);
3591
        opt_default("gop", norm ? "18" : "15");
3592

    
3593
        opt_default("b", "1150000");
3594
        opt_default("maxrate", "1150000");
3595
        opt_default("minrate", "1150000");
3596
        opt_default("bufsize", "327680"); // 40*1024*8;
3597

    
3598
        opt_default("ab", "224000");
3599
        audio_sample_rate = 44100;
3600
        audio_channels = 2;
3601

    
3602
        opt_default("packetsize", "2324");
3603
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3604

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

    
3613
        opt_video_codec("mpeg2video");
3614
        opt_audio_codec("mp2");
3615
        opt_format("svcd");
3616

    
3617
        opt_frame_size(norm ? "480x480" : "480x576");
3618
        opt_frame_rate(NULL, frame_rates[norm]);
3619
        opt_default("gop", norm ? "18" : "15");
3620

    
3621
        opt_default("b", "2040000");
3622
        opt_default("maxrate", "2516000");
3623
        opt_default("minrate", "0"); //1145000;
3624
        opt_default("bufsize", "1835008"); //224*1024*8;
3625
        opt_default("flags", "+scan_offset");
3626

    
3627

    
3628
        opt_default("ab", "224000");
3629
        audio_sample_rate = 44100;
3630

    
3631
        opt_default("packetsize", "2324");
3632

    
3633
    } else if(!strcmp(arg, "dvd")) {
3634

    
3635
        opt_video_codec("mpeg2video");
3636
        opt_audio_codec("ac3");
3637
        opt_format("dvd");
3638

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

    
3643
        opt_default("b", "6000000");
3644
        opt_default("maxrate", "9000000");
3645
        opt_default("minrate", "0"); //1500000;
3646
        opt_default("bufsize", "1835008"); //224*1024*8;
3647

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

    
3651
        opt_default("ab", "448000");
3652
        audio_sample_rate = 48000;
3653

    
3654
    } else if(!strncmp(arg, "dv", 2)) {
3655

    
3656
        opt_format("dv");
3657

    
3658
        opt_frame_size(norm ? "720x480" : "720x576");
3659
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3660
                                             (norm ? "yuv411p" : "yuv420p"));
3661
        opt_frame_rate(NULL, frame_rates[norm]);
3662

    
3663
        audio_sample_rate = 48000;
3664
        audio_channels = 2;
3665

    
3666
    } else {
3667
        fprintf(stderr, "Unknown target: %s\n", arg);
3668
        av_exit(1);
3669
    }
3670
}
3671

    
3672
static void opt_vstats_file (const char *arg)
3673
{
3674
    av_free (vstats_filename);
3675
    vstats_filename=av_strdup (arg);
3676
}
3677

    
3678
static void opt_vstats (void)
3679
{
3680
    char filename[40];
3681
    time_t today2 = time(NULL);
3682
    struct tm *today = localtime(&today2);
3683

    
3684
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3685
             today->tm_sec);
3686
    opt_vstats_file(filename);
3687
}
3688

    
3689
static int opt_bsf(const char *opt, const char *arg)
3690
{
3691
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3692
    AVBitStreamFilterContext **bsfp;
3693

    
3694
    if(!bsfc){
3695
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3696
        av_exit(1);
3697
    }
3698

    
3699
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3700
          *opt == 'a' ? &audio_bitstream_filters :
3701
                        &subtitle_bitstream_filters;
3702
    while(*bsfp)
3703
        bsfp= &(*bsfp)->next;
3704

    
3705
    *bsfp= bsfc;
3706

    
3707
    return 0;
3708
}
3709

    
3710
static int opt_preset(const char *opt, const char *arg)
3711
{
3712
    FILE *f=NULL;
3713
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3714
    int i;
3715
    const char *base[2]= { getenv("HOME"),
3716
                           FFMPEG_DATADIR,
3717
                         };
3718

    
3719
    for(i=!base[0]; i<2 && !f; i++){
3720
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3721
        f= fopen(filename, "r");
3722
        if(!f){
3723
            char *codec_name= *opt == 'v' ? video_codec_name :
3724
                              *opt == 'a' ? audio_codec_name :
3725
                                            subtitle_codec_name;
3726
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3727
            f= fopen(filename, "r");
3728
        }
3729
    }
3730
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3731
              is_dos_path(arg))){
3732
        av_strlcpy(filename, arg, sizeof(filename));
3733
        f= fopen(filename, "r");
3734
    }
3735

    
3736
    if(!f){
3737
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3738
        av_exit(1);
3739
    }
3740

    
3741
    while(!feof(f)){
3742
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3743
        if(line[0] == '#' && !e)
3744
            continue;
3745
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3746
        if(e){
3747
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3748
            av_exit(1);
3749
        }
3750
        if(!strcmp(tmp, "acodec")){
3751
            opt_audio_codec(tmp2);
3752
        }else if(!strcmp(tmp, "vcodec")){
3753
            opt_video_codec(tmp2);
3754
        }else if(!strcmp(tmp, "scodec")){
3755
            opt_subtitle_codec(tmp2);
3756
        }else if(opt_default(tmp, tmp2) < 0){
3757
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3758
            av_exit(1);
3759
        }
3760
    }
3761

    
3762
    fclose(f);
3763

    
3764
    return 0;
3765
}
3766

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

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

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

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

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

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

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

    
3886
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3887
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3888
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3889

    
3890
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3891
    { NULL, },
3892
};
3893

    
3894
int main(int argc, char **argv)
3895
{
3896
    int i;
3897
    int64_t ti;
3898

    
3899
    avcodec_register_all();
3900
    avdevice_register_all();
3901
    av_register_all();
3902

    
3903
    if(isatty(STDIN_FILENO))
3904
        url_set_interrupt_cb(decode_interrupt_cb);
3905

    
3906
    for(i=0; i<CODEC_TYPE_NB; i++){
3907
        avcodec_opts[i]= avcodec_alloc_context2(i);
3908
    }
3909
    avformat_opts = avformat_alloc_context();
3910
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3911

    
3912
    show_banner();
3913

    
3914
    /* parse options */
3915
    parse_options(argc, argv, options, opt_output_file);
3916

    
3917
    /* file converter / grab */
3918
    if (nb_output_files <= 0) {
3919
        fprintf(stderr, "At least one output file must be specified\n");
3920
        av_exit(1);
3921
    }
3922

    
3923
    if (nb_input_files == 0) {
3924
        fprintf(stderr, "At least one input file must be specified\n");
3925
        av_exit(1);
3926
    }
3927

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

    
3937
    return av_exit(0);
3938
}