Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 7c8689ef

History | View | Annotate | Download (141 KB)

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

    
22
/* needed for usleep() */
23
#define _XOPEN_SOURCE 600
24

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

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

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

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

    
65
#include "cmdutils.h"
66

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

    
70
#undef exit
71

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

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

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

    
89
static const OptionDef options[];
90

    
91
#define MAX_FILES 20
92

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

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

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

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

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

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

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

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

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

    
197
static int rate_emu = 0;
198

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

    
202
static int audio_volume = 256;
203

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

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

    
221
static unsigned int sws_flags = SWS_BICUBIC;
222

    
223
static int64_t timer_start;
224

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

    
229
static short *samples;
230

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

    
236
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
237

    
238
struct AVInputStream;
239

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

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

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

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

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

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

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

    
299
#if HAVE_TERMIOS_H
300

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

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

    
312
static volatile sig_atomic_t received_sigterm = 0;
313

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
423
    av_free(opt_names);
424

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

    
429
    av_free(video_standard);
430

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
527
        bsfc= bsfc->next;
528
    }
529

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

    
537
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
538

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
762
        if (do_deinterlace){
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
            av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
773
        }
774
    } else {
775
        picture2 = picture;
776
    }
777

    
778
    if (picture != picture2)
779
        *picture = *picture2;
780
    *bufp = buf;
781
}
782

    
783
/* we begin to correct av delay at this threshold */
784
#define AV_DELAY_MAX 0.100
785

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

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

    
805
    enc = ost->st->codec;
806

    
807
    if (!subtitle_out) {
808
        subtitle_out = av_malloc(subtitle_out_max_size);
809
    }
810

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

    
819
    for(i = 0; i < nb; i++) {
820
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
821
                                                    subtitle_out_max_size, sub);
822

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

    
840
static int bit_buffer_size= 1024*256;
841
static uint8_t *bit_buffer= NULL;
842

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

    
854
    avcodec_get_frame_defaults(&picture_crop_temp);
855
    avcodec_get_frame_defaults(&picture_pad_temp);
856

    
857
    enc = ost->st->codec;
858
    dec = ist->st->codec;
859

    
860
    /* by default, we output a single frame */
861
    nb_frames = 1;
862

    
863
    *frame_size = 0;
864

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

    
891
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
892
    if (nb_frames <= 0)
893
        return;
894

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

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

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

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

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

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

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

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

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

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

    
1017
static double psnr(double d){
1018
    return -10.0*log(d)/log(10.0);
1019
}
1020

    
1021
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1022
                           int frame_size)
1023
{
1024
    AVCodecContext *enc;
1025
    int frame_number;
1026
    double ti1, bitrate, avg_bitrate;
1027

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

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

    
1044
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1045
        /* compute pts value */
1046
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1047
        if (ti1 < 0.01)
1048
            ti1 = 0.01;
1049

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

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

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

    
1085

    
1086
    oc = output_files[0];
1087

    
1088
    total_size = url_fsize(oc->pb);
1089
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1090
        total_size= url_ftell(oc->pb);
1091

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

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

    
1153
    if (verbose || is_last_report) {
1154
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1155

    
1156
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1157
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1158
            (double)total_size / 1024, ti1, bitrate);
1159

    
1160
        if (verbose > 1)
1161
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1162
                  nb_frames_dup, nb_frames_drop);
1163

    
1164
        if (verbose >= 0)
1165
            fprintf(stderr, "%s    \r", buf);
1166

    
1167
        fflush(stderr);
1168
    }
1169

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

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

    
1199
    if(ist->next_pts == AV_NOPTS_VALUE)
1200
        ist->next_pts= ist->pts;
1201

    
1202
    if (pkt == NULL) {
1203
        /* EOF handling */
1204
        av_init_packet(&avpkt);
1205
        avpkt.data = NULL;
1206
        avpkt.size = 0;
1207
        goto handle_eof;
1208
    } else {
1209
        avpkt = *pkt;
1210
    }
1211

    
1212
    if(pkt->dts != AV_NOPTS_VALUE)
1213
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1214

    
1215
    //while we have more to decode or while the decoder did output something on EOF
1216
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1217
    handle_eof:
1218
        ist->pts= ist->next_pts;
1219

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

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

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

    
1311
        buffer_to_free = NULL;
1312
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1313
            pre_process_video_frame(ist, (AVPicture *)&picture,
1314
                                    &buffer_to_free);
1315
        }
1316

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

    
1331
        /* frame rate emulation */
1332
        if (rate_emu) {
1333
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1334
            int64_t now = av_gettime() - ist->start;
1335
            if (pts > now)
1336
                usleep(pts - now);
1337
        }
1338

    
1339
        /* if output time reached then transcode raw format,
1340
           encode packets and output them */
1341
        if (start_time == 0 || ist->pts >= start_time)
1342
            for(i=0;i<nb_ostreams;i++) {
1343
                int frame_size;
1344

    
1345
                ost = ost_table[i];
1346
                if (ost->source_index == ist_index) {
1347
                    os = output_files[ost->file_index];
1348

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

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

    
1380
                        av_init_packet(&opkt);
1381

    
1382
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1383
                            continue;
1384

    
1385
                        /* no reencoding needed : output the packet directly */
1386
                        /* force the input stream PTS */
1387

    
1388
                        avcodec_get_frame_defaults(&avframe);
1389
                        ost->st->codec->coded_frame= &avframe;
1390
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1391

    
1392
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1393
                            audio_size += data_size;
1394
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1395
                            video_size += data_size;
1396
                            ost->sync_opts++;
1397
                        }
1398

    
1399
                        opkt.stream_index= ost->index;
1400
                        if(pkt->pts != AV_NOPTS_VALUE)
1401
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1402
                        else
1403
                            opkt.pts= AV_NOPTS_VALUE;
1404

    
1405
                        if (pkt->dts == AV_NOPTS_VALUE)
1406
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1407
                        else
1408
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1409
                        opkt.dts -= ost_tb_start_time;
1410

    
1411
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1412
                        opkt.flags= pkt->flags;
1413

    
1414
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1415
                        if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1416
                            opkt.destruct= av_destruct_packet;
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 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1468
                                int fs_tmp = enc->frame_size;
1469
                                enc->frame_size = fifo_bytes / (2 * enc->channels);
1470
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1471
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1472
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1473
                                                          ost->st->time_base.num, enc->sample_rate);
1474
                                enc->frame_size = fs_tmp;
1475
                            }
1476
                            if(ret <= 0) {
1477
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1478
                            }
1479
                            if (ret < 0) {
1480
                                fprintf(stderr, "Audio encoding failed\n");
1481
                                av_exit(1);
1482
                            }
1483
                            audio_size += ret;
1484
                            pkt.flags |= PKT_FLAG_KEY;
1485
                            break;
1486
                        case CODEC_TYPE_VIDEO:
1487
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1488
                            if (ret < 0) {
1489
                                fprintf(stderr, "Video encoding failed\n");
1490
                                av_exit(1);
1491
                            }
1492
                            video_size += ret;
1493
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1494
                                pkt.flags |= PKT_FLAG_KEY;
1495
                            if (ost->logfile && enc->stats_out) {
1496
                                fprintf(ost->logfile, "%s", enc->stats_out);
1497
                            }
1498
                            break;
1499
                        default:
1500
                            ret=-1;
1501
                        }
1502

    
1503
                        if(ret<=0)
1504
                            break;
1505
                        pkt.data= bit_buffer;
1506
                        pkt.size= ret;
1507
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1508
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1509
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1510
                    }
1511
                }
1512
            }
1513
        }
1514
    }
1515

    
1516
    return 0;
1517
 fail_decode:
1518
    return -1;
1519
}
1520

    
1521
static void print_sdp(AVFormatContext **avc, int n)
1522
{
1523
    char sdp[2048];
1524

    
1525
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1526
    printf("SDP:\n%s\n", sdp);
1527
    fflush(stdout);
1528
}
1529

    
1530
static int stream_index_from_inputs(AVFormatContext **input_files,
1531
                                    int nb_input_files,
1532
                                    AVInputFile *file_table,
1533
                                    AVInputStream **ist_table,
1534
                                    enum CodecType type,
1535
                                    int programid)
1536
{
1537
    int p, q, z;
1538
    for(z=0; z<nb_input_files; z++) {
1539
        AVFormatContext *ic = input_files[z];
1540
        for(p=0; p<ic->nb_programs; p++) {
1541
            AVProgram *program = ic->programs[p];
1542
            if(program->id != programid)
1543
                continue;
1544
            for(q=0; q<program->nb_stream_indexes; q++) {
1545
                int sidx = program->stream_index[q];
1546
                int ris = file_table[z].ist_index + sidx;
1547
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1548
                    return ris;
1549
            }
1550
        }
1551
    }
1552

    
1553
    return -1;
1554
}
1555

    
1556
/*
1557
 * The following code is the main loop of the file converter
1558
 */
1559
static int av_encode(AVFormatContext **output_files,
1560
                     int nb_output_files,
1561
                     AVFormatContext **input_files,
1562
                     int nb_input_files,
1563
                     AVStreamMap *stream_maps, int nb_stream_maps)
1564
{
1565
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1566
    AVFormatContext *is, *os;
1567
    AVCodecContext *codec, *icodec;
1568
    AVOutputStream *ost, **ost_table = NULL;
1569
    AVInputStream *ist, **ist_table = NULL;
1570
    AVInputFile *file_table;
1571
    char error[1024];
1572
    int key;
1573
    int want_sdp = 1;
1574
    uint8_t no_packet[MAX_FILES]={0};
1575
    int no_packet_count=0;
1576

    
1577
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1578
    if (!file_table)
1579
        goto fail;
1580

    
1581
    /* input stream init */
1582
    j = 0;
1583
    for(i=0;i<nb_input_files;i++) {
1584
        is = input_files[i];
1585
        file_table[i].ist_index = j;
1586
        file_table[i].nb_streams = is->nb_streams;
1587
        j += is->nb_streams;
1588
    }
1589
    nb_istreams = j;
1590

    
1591
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1592
    if (!ist_table)
1593
        goto fail;
1594

    
1595
    for(i=0;i<nb_istreams;i++) {
1596
        ist = av_mallocz(sizeof(AVInputStream));
1597
        if (!ist)
1598
            goto fail;
1599
        ist_table[i] = ist;
1600
    }
1601
    j = 0;
1602
    for(i=0;i<nb_input_files;i++) {
1603
        is = input_files[i];
1604
        for(k=0;k<is->nb_streams;k++) {
1605
            ist = ist_table[j++];
1606
            ist->st = is->streams[k];
1607
            ist->file_index = i;
1608
            ist->index = k;
1609
            ist->discard = 1; /* the stream is discarded by default
1610
                                 (changed later) */
1611

    
1612
            if (rate_emu) {
1613
                ist->start = av_gettime();
1614
            }
1615
        }
1616
    }
1617

    
1618
    /* output stream init */
1619
    nb_ostreams = 0;
1620
    for(i=0;i<nb_output_files;i++) {
1621
        os = output_files[i];
1622
        if (!os->nb_streams) {
1623
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1624
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1625
            av_exit(1);
1626
        }
1627
        nb_ostreams += os->nb_streams;
1628
    }
1629
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1630
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1631
        av_exit(1);
1632
    }
1633

    
1634
    /* Sanity check the mapping args -- do the input files & streams exist? */
1635
    for(i=0;i<nb_stream_maps;i++) {
1636
        int fi = stream_maps[i].file_index;
1637
        int si = stream_maps[i].stream_index;
1638

    
1639
        if (fi < 0 || fi > nb_input_files - 1 ||
1640
            si < 0 || si > file_table[fi].nb_streams - 1) {
1641
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1642
            av_exit(1);
1643
        }
1644
        fi = stream_maps[i].sync_file_index;
1645
        si = stream_maps[i].sync_stream_index;
1646
        if (fi < 0 || fi > nb_input_files - 1 ||
1647
            si < 0 || si > file_table[fi].nb_streams - 1) {
1648
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1649
            av_exit(1);
1650
        }
1651
    }
1652

    
1653
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1654
    if (!ost_table)
1655
        goto fail;
1656
    for(i=0;i<nb_ostreams;i++) {
1657
        ost = av_mallocz(sizeof(AVOutputStream));
1658
        if (!ost)
1659
            goto fail;
1660
        ost_table[i] = ost;
1661
    }
1662

    
1663
    n = 0;
1664
    for(k=0;k<nb_output_files;k++) {
1665
        os = output_files[k];
1666
        for(i=0;i<os->nb_streams;i++,n++) {
1667
            int found;
1668
            ost = ost_table[n];
1669
            ost->file_index = k;
1670
            ost->index = i;
1671
            ost->st = os->streams[i];
1672
            if (nb_stream_maps > 0) {
1673
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1674
                    stream_maps[n].stream_index;
1675

    
1676
                /* Sanity check that the stream types match */
1677
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1678
                    int i= ost->file_index;
1679
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1680
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1681
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1682
                        ost->file_index, ost->index);
1683
                    av_exit(1);
1684
                }
1685

    
1686
            } else {
1687
                if(opt_programid) {
1688
                    found = 0;
1689
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1690
                    if(j != -1) {
1691
                        ost->source_index = j;
1692
                        found = 1;
1693
                    }
1694
                } else {
1695
                    /* get corresponding input stream index : we select the first one with the right type */
1696
                    found = 0;
1697
                    for(j=0;j<nb_istreams;j++) {
1698
                        ist = ist_table[j];
1699
                        if (ist->discard &&
1700
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1701
                            ost->source_index = j;
1702
                            found = 1;
1703
                            break;
1704
                        }
1705
                    }
1706
                }
1707

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

    
1736
    /* for each output stream, we compute the right encoding parameters */
1737
    for(i=0;i<nb_ostreams;i++) {
1738
        AVMetadataTag *lang;
1739
        ost = ost_table[i];
1740
        os = output_files[ost->file_index];
1741
        ist = ist_table[ost->source_index];
1742

    
1743
        codec = ost->st->codec;
1744
        icodec = ist->st->codec;
1745

    
1746
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1747
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1748
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1749

    
1750
        ost->st->disposition = ist->st->disposition;
1751

    
1752
        if (ost->st->stream_copy) {
1753
            /* if stream_copy is selected, no need to decode or encode */
1754
            codec->codec_id = icodec->codec_id;
1755
            codec->codec_type = icodec->codec_type;
1756

    
1757
            if(!codec->codec_tag){
1758
                if(   !os->oformat->codec_tag
1759
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1760
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1761
                    codec->codec_tag = icodec->codec_tag;
1762
            }
1763

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

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

    
1918
    if (!bit_buffer)
1919
        bit_buffer = av_malloc(bit_buffer_size);
1920
    if (!bit_buffer) {
1921
        ret = AVERROR(ENOMEM);
1922
        goto fail;
1923
    }
1924

    
1925
    /* open each encoder */
1926
    for(i=0;i<nb_ostreams;i++) {
1927
        ost = ost_table[i];
1928
        if (ost->encoding_needed) {
1929
            AVCodec *codec = output_codecs[i];
1930
            if (!codec)
1931
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
1932
            if (!codec) {
1933
                snprintf(error, sizeof(error), "Unsupported codec for output stream #%d.%d",
1934
                        ost->file_index, ost->index);
1935
                ret = AVERROR(EINVAL);
1936
                goto dump_format;
1937
            }
1938
            if (avcodec_open(ost->st->codec, codec) < 0) {
1939
                snprintf(error, sizeof(error), "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1940
                        ost->file_index, ost->index);
1941
                ret = AVERROR(EINVAL);
1942
                goto dump_format;
1943
            }
1944
            extra_size += ost->st->codec->extradata_size;
1945
        }
1946
    }
1947

    
1948
    /* open each decoder */
1949
    for(i=0;i<nb_istreams;i++) {
1950
        ist = ist_table[i];
1951
        if (ist->decoding_needed) {
1952
            AVCodec *codec = input_codecs[i];
1953
            if (!codec)
1954
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
1955
            if (!codec) {
1956
                snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
1957
                        ist->st->codec->codec_id, ist->file_index, ist->index);
1958
                ret = AVERROR(EINVAL);
1959
                goto dump_format;
1960
            }
1961
            if (avcodec_open(ist->st->codec, codec) < 0) {
1962
                snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
1963
                        ist->file_index, ist->index);
1964
                ret = AVERROR(EINVAL);
1965
                goto dump_format;
1966
            }
1967
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1968
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1969
        }
1970
    }
1971

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

    
1981
    /* set meta data information from input file if required */
1982
    for (i=0;i<nb_meta_data_maps;i++) {
1983
        AVFormatContext *out_file;
1984
        AVFormatContext *in_file;
1985
        AVMetadataTag *mtag;
1986

    
1987
        int out_file_index = meta_data_maps[i].out_file;
1988
        int in_file_index = meta_data_maps[i].in_file;
1989
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
1990
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
1991
                     out_file_index, out_file_index, in_file_index);
1992
            ret = AVERROR(EINVAL);
1993
            goto dump_format;
1994
        }
1995
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
1996
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
1997
                     in_file_index, out_file_index, in_file_index);
1998
            ret = AVERROR(EINVAL);
1999
            goto dump_format;
2000
        }
2001

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

    
2005

    
2006
        mtag=NULL;
2007
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2008
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2009
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2010
                                    in_file->iformat->metadata_conv);
2011
    }
2012

    
2013
    /* open files and write file headers */
2014
    for(i=0;i<nb_output_files;i++) {
2015
        os = output_files[i];
2016
        if (av_write_header(os) < 0) {
2017
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2018
            ret = AVERROR(EINVAL);
2019
            goto dump_format;
2020
        }
2021
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2022
            want_sdp = 0;
2023
        }
2024
    }
2025

    
2026
 dump_format:
2027
    /* dump the file output parameters - cannot be done before in case
2028
       of stream copy */
2029
    for(i=0;i<nb_output_files;i++) {
2030
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2031
    }
2032

    
2033
    /* dump the stream mapping */
2034
    if (verbose >= 0) {
2035
        fprintf(stderr, "Stream mapping:\n");
2036
        for(i=0;i<nb_ostreams;i++) {
2037
            ost = ost_table[i];
2038
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2039
                    ist_table[ost->source_index]->file_index,
2040
                    ist_table[ost->source_index]->index,
2041
                    ost->file_index,
2042
                    ost->index);
2043
            if (ost->sync_ist != ist_table[ost->source_index])
2044
                fprintf(stderr, " [sync #%d.%d]",
2045
                        ost->sync_ist->file_index,
2046
                        ost->sync_ist->index);
2047
            fprintf(stderr, "\n");
2048
        }
2049
    }
2050

    
2051
    if (ret) {
2052
        fprintf(stderr, "%s\n", error);
2053
        goto fail;
2054
    }
2055

    
2056
    if (want_sdp) {
2057
        print_sdp(output_files, nb_output_files);
2058
    }
2059

    
2060
    if (!using_stdin && verbose >= 0) {
2061
        fprintf(stderr, "Press [q] to stop encoding\n");
2062
        url_set_interrupt_cb(decode_interrupt_cb);
2063
    }
2064
    term_init();
2065

    
2066
    key = -1;
2067
    timer_start = av_gettime();
2068

    
2069
    for(; received_sigterm == 0;) {
2070
        int file_index, ist_index;
2071
        AVPacket pkt;
2072
        double ipts_min;
2073
        double opts_min;
2074

    
2075
    redo:
2076
        ipts_min= 1e100;
2077
        opts_min= 1e100;
2078
        /* if 'q' pressed, exits */
2079
        if (!using_stdin) {
2080
            if (q_pressed)
2081
                break;
2082
            /* read_key() returns 0 on EOF */
2083
            key = read_key();
2084
            if (key == 'q')
2085
                break;
2086
        }
2087

    
2088
        /* select the stream that we must read now by looking at the
2089
           smallest output pts */
2090
        file_index = -1;
2091
        for(i=0;i<nb_ostreams;i++) {
2092
            double ipts, opts;
2093
            ost = ost_table[i];
2094
            os = output_files[ost->file_index];
2095
            ist = ist_table[ost->source_index];
2096
            if(no_packet[ist->file_index])
2097
                continue;
2098
            if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2099
                opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2100
            else
2101
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2102
            ipts = (double)ist->pts;
2103
            if (!file_table[ist->file_index].eof_reached){
2104
                if(ipts < ipts_min) {
2105
                    ipts_min = ipts;
2106
                    if(input_sync ) file_index = ist->file_index;
2107
                }
2108
                if(opts < opts_min) {
2109
                    opts_min = opts;
2110
                    if(!input_sync) file_index = ist->file_index;
2111
                }
2112
            }
2113
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2114
                file_index= -1;
2115
                break;
2116
            }
2117
        }
2118
        /* if none, if is finished */
2119
        if (file_index < 0) {
2120
            if(no_packet_count){
2121
                no_packet_count=0;
2122
                memset(no_packet, 0, sizeof(no_packet));
2123
                usleep(10000);
2124
                continue;
2125
            }
2126
            break;
2127
        }
2128

    
2129
        /* finish if recording time exhausted */
2130
        if (opts_min >= (recording_time / 1000000.0))
2131
            break;
2132

    
2133
        /* finish if limit size exhausted */
2134
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2135
            break;
2136

    
2137
        /* read a frame from it and output it in the fifo */
2138
        is = input_files[file_index];
2139
        ret= av_read_frame(is, &pkt);
2140
        if(ret == AVERROR(EAGAIN)){
2141
            no_packet[file_index]=1;
2142
            no_packet_count++;
2143
            continue;
2144
        }
2145
        if (ret < 0) {
2146
            file_table[file_index].eof_reached = 1;
2147
            if (opt_shortest)
2148
                break;
2149
            else
2150
                continue;
2151
        }
2152

    
2153
        no_packet_count=0;
2154
        memset(no_packet, 0, sizeof(no_packet));
2155

    
2156
        if (do_pkt_dump) {
2157
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2158
        }
2159
        /* the following test is needed in case new streams appear
2160
           dynamically in stream : we ignore them */
2161
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2162
            goto discard_packet;
2163
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2164
        ist = ist_table[ist_index];
2165
        if (ist->discard)
2166
            goto discard_packet;
2167

    
2168
        if (pkt.dts != AV_NOPTS_VALUE)
2169
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2170
        if (pkt.pts != AV_NOPTS_VALUE)
2171
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2172

    
2173
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2174
            if(pkt.pts != AV_NOPTS_VALUE)
2175
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2176
            if(pkt.dts != AV_NOPTS_VALUE)
2177
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2178
        }
2179

    
2180
//        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);
2181
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2182
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2183
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2184
            int64_t delta= pkt_dts - ist->next_pts;
2185
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2186
                input_files_ts_offset[ist->file_index]-= delta;
2187
                if (verbose > 2)
2188
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2189
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2190
                if(pkt.pts != AV_NOPTS_VALUE)
2191
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2192
            }
2193
        }
2194

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

    
2198
            if (verbose >= 0)
2199
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2200
                        ist->file_index, ist->index);
2201
            if (exit_on_error)
2202
                av_exit(1);
2203
            av_free_packet(&pkt);
2204
            goto redo;
2205
        }
2206

    
2207
    discard_packet:
2208
        av_free_packet(&pkt);
2209

    
2210
        /* dump report by using the output first video and audio streams */
2211
        print_report(output_files, ost_table, nb_ostreams, 0);
2212
    }
2213

    
2214
    /* at the end of stream, we must flush the decoder buffers */
2215
    for(i=0;i<nb_istreams;i++) {
2216
        ist = ist_table[i];
2217
        if (ist->decoding_needed) {
2218
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2219
        }
2220
    }
2221

    
2222
    term_exit();
2223

    
2224
    /* write the trailer if needed and close file */
2225
    for(i=0;i<nb_output_files;i++) {
2226
        os = output_files[i];
2227
        av_write_trailer(os);
2228
    }
2229

    
2230
    /* dump report by using the first video and audio streams */
2231
    print_report(output_files, ost_table, nb_ostreams, 1);
2232

    
2233
    /* close each encoder */
2234
    for(i=0;i<nb_ostreams;i++) {
2235
        ost = ost_table[i];
2236
        if (ost->encoding_needed) {
2237
            av_freep(&ost->st->codec->stats_in);
2238
            avcodec_close(ost->st->codec);
2239
        }
2240
    }
2241

    
2242
    /* close each decoder */
2243
    for(i=0;i<nb_istreams;i++) {
2244
        ist = ist_table[i];
2245
        if (ist->decoding_needed) {
2246
            avcodec_close(ist->st->codec);
2247
        }
2248
    }
2249

    
2250
    /* finished ! */
2251
    ret = 0;
2252

    
2253
 fail:
2254
    av_freep(&bit_buffer);
2255
    av_free(file_table);
2256

    
2257
    if (ist_table) {
2258
        for(i=0;i<nb_istreams;i++) {
2259
            ist = ist_table[i];
2260
            av_free(ist);
2261
        }
2262
        av_free(ist_table);
2263
    }
2264
    if (ost_table) {
2265
        for(i=0;i<nb_ostreams;i++) {
2266
            ost = ost_table[i];
2267
            if (ost) {
2268
                if (ost->logfile) {
2269
                    fclose(ost->logfile);
2270
                    ost->logfile = NULL;
2271
                }
2272
                av_fifo_free(ost->fifo); /* works even if fifo is not
2273
                                             initialized but set to zero */
2274
                av_free(ost->pict_tmp.data[0]);
2275
                if (ost->video_resample)
2276
                    sws_freeContext(ost->img_resample_ctx);
2277
                if (ost->resample)
2278
                    audio_resample_close(ost->resample);
2279
                if (ost->reformat_ctx)
2280
                    av_audio_convert_free(ost->reformat_ctx);
2281
                av_free(ost);
2282
            }
2283
        }
2284
        av_free(ost_table);
2285
    }
2286
    return ret;
2287
}
2288

    
2289
#if 0
2290
int file_read(const char *filename)
2291
{
2292
    URLContext *h;
2293
    unsigned char buffer[1024];
2294
    int len, i;
2295

2296
    if (url_open(&h, filename, O_RDONLY) < 0) {
2297
        printf("could not open '%s'\n", filename);
2298
        return -1;
2299
    }
2300
    for(;;) {
2301
        len = url_read(h, buffer, sizeof(buffer));
2302
        if (len <= 0)
2303
            break;
2304
        for(i=0;i<len;i++) putchar(buffer[i]);
2305
    }
2306
    url_close(h);
2307
    return 0;
2308
}
2309
#endif
2310

    
2311
static void opt_format(const char *arg)
2312
{
2313
    /* compatibility stuff for pgmyuv */
2314
    if (!strcmp(arg, "pgmyuv")) {
2315
        pgmyuv_compatibility_hack=1;
2316
//        opt_image_format(arg);
2317
        arg = "image2";
2318
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2319
    }
2320

    
2321
    file_iformat = av_find_input_format(arg);
2322
    file_oformat = guess_format(arg, NULL, NULL);
2323
    if (!file_iformat && !file_oformat) {
2324
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2325
        av_exit(1);
2326
    }
2327
}
2328

    
2329
static void opt_video_rc_override_string(const char *arg)
2330
{
2331
    video_rc_override_string = arg;
2332
}
2333

    
2334
static int opt_me_threshold(const char *opt, const char *arg)
2335
{
2336
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2337
    return 0;
2338
}
2339

    
2340
static void opt_loglevel(const char *opt, const char *arg)
2341
{
2342
    int level = parse_number_or_die(opt, arg, OPT_INT, INT_MIN, INT_MAX);
2343
    av_log_set_level(level);
2344
}
2345

    
2346
static int opt_verbose(const char *opt, const char *arg)
2347
{
2348
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2349
    return 0;
2350
}
2351

    
2352
static int opt_frame_rate(const char *opt, const char *arg)
2353
{
2354
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2355
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2356
        av_exit(1);
2357
    }
2358
    return 0;
2359
}
2360

    
2361
static int opt_bitrate(const char *opt, const char *arg)
2362
{
2363
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2364

    
2365
    opt_default(opt, arg);
2366

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

    
2370
    return 0;
2371
}
2372

    
2373
static void opt_frame_crop_top(const char *arg)
2374
{
2375
    frame_topBand = atoi(arg);
2376
    if (frame_topBand < 0) {
2377
        fprintf(stderr, "Incorrect top crop size\n");
2378
        av_exit(1);
2379
    }
2380
    if ((frame_topBand % 2) != 0) {
2381
        fprintf(stderr, "Top crop size must be a multiple of 2\n");
2382
        av_exit(1);
2383
    }
2384
    if ((frame_topBand) >= frame_height){
2385
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2386
        av_exit(1);
2387
    }
2388
    frame_height -= frame_topBand;
2389
}
2390

    
2391
static void opt_frame_crop_bottom(const char *arg)
2392
{
2393
    frame_bottomBand = atoi(arg);
2394
    if (frame_bottomBand < 0) {
2395
        fprintf(stderr, "Incorrect bottom crop size\n");
2396
        av_exit(1);
2397
    }
2398
    if ((frame_bottomBand % 2) != 0) {
2399
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2400
        av_exit(1);
2401
    }
2402
    if ((frame_bottomBand) >= frame_height){
2403
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2404
        av_exit(1);
2405
    }
2406
    frame_height -= frame_bottomBand;
2407
}
2408

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

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

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

    
2457

    
2458
#define SCALEBITS 10
2459
#define ONE_HALF  (1 << (SCALEBITS - 1))
2460
#define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2461

    
2462
#define RGB_TO_Y(r, g, b) \
2463
((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2464
  FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2465

    
2466
#define RGB_TO_U(r1, g1, b1, shift)\
2467
(((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2468
     FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2469

    
2470
#define RGB_TO_V(r1, g1, b1, shift)\
2471
(((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2472
   FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2473

    
2474
static void opt_pad_color(const char *arg) {
2475
    /* Input is expected to be six hex digits similar to
2476
       how colors are expressed in html tags (but without the #) */
2477
    int rgb = strtol(arg, NULL, 16);
2478
    int r,g,b;
2479

    
2480
    r = (rgb >> 16);
2481
    g = ((rgb >> 8) & 255);
2482
    b = (rgb & 255);
2483

    
2484
    padcolor[0] = RGB_TO_Y(r,g,b);
2485
    padcolor[1] = RGB_TO_U(r,g,b,0);
2486
    padcolor[2] = RGB_TO_V(r,g,b,0);
2487
}
2488

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

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

    
2515

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

    
2529

    
2530
static void opt_frame_pad_right(const char *arg)
2531
{
2532
    frame_padright = atoi(arg);
2533
    if (frame_padright < 0) {
2534
        fprintf(stderr, "Incorrect right pad size\n");
2535
        av_exit(1);
2536
    }
2537
    if ((frame_padright % 2) != 0) {
2538
        fprintf(stderr, "Right pad size must be a multiple of 2\n");
2539
        av_exit(1);
2540
    }
2541
}
2542

    
2543
static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2544
{
2545
    int i;
2546
    char fmt_str[128];
2547
    for (i=-1; i < nb_fmts; i++) {
2548
        get_fmt_string (fmt_str, sizeof(fmt_str), i);
2549
        fprintf(stdout, "%s\n", fmt_str);
2550
    }
2551
}
2552

    
2553
static void opt_frame_pix_fmt(const char *arg)
2554
{
2555
    if (strcmp(arg, "list")) {
2556
        frame_pix_fmt = avcodec_get_pix_fmt(arg);
2557
        if (frame_pix_fmt == PIX_FMT_NONE) {
2558
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2559
            av_exit(1);
2560
        }
2561
    } else {
2562
        list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2563
        av_exit(0);
2564
    }
2565
}
2566

    
2567
static void opt_frame_aspect_ratio(const char *arg)
2568
{
2569
    int x = 0, y = 0;
2570
    double ar = 0;
2571
    const char *p;
2572
    char *end;
2573

    
2574
    p = strchr(arg, ':');
2575
    if (p) {
2576
        x = strtol(arg, &end, 10);
2577
        if (end == p)
2578
            y = strtol(end+1, &end, 10);
2579
        if (x > 0 && y > 0)
2580
            ar = (double)x / (double)y;
2581
    } else
2582
        ar = strtod(arg, NULL);
2583

    
2584
    if (!ar) {
2585
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2586
        av_exit(1);
2587
    }
2588
    frame_aspect_ratio = ar;
2589
}
2590

    
2591
static int opt_metadata(const char *opt, const char *arg)
2592
{
2593
    char *mid= strchr(arg, '=');
2594

    
2595
    if(!mid){
2596
        fprintf(stderr, "Missing =\n");
2597
        av_exit(1);
2598
    }
2599
    *mid++= 0;
2600

    
2601
    metadata_count++;
2602
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2603
    metadata[metadata_count-1].key  = av_strdup(arg);
2604
    metadata[metadata_count-1].value= av_strdup(mid);
2605

    
2606
    return 0;
2607
}
2608

    
2609
static void opt_qscale(const char *arg)
2610
{
2611
    video_qscale = atof(arg);
2612
    if (video_qscale <= 0 ||
2613
        video_qscale > 255) {
2614
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2615
        av_exit(1);
2616
    }
2617
}
2618

    
2619
static void opt_top_field_first(const char *arg)
2620
{
2621
    top_field_first= atoi(arg);
2622
}
2623

    
2624
static int opt_thread_count(const char *opt, const char *arg)
2625
{
2626
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2627
#if !HAVE_THREADS
2628
    if (verbose >= 0)
2629
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2630
#endif
2631
    return 0;
2632
}
2633

    
2634
static void opt_audio_sample_fmt(const char *arg)
2635
{
2636
    if (strcmp(arg, "list"))
2637
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2638
    else {
2639
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2640
        av_exit(0);
2641
    }
2642
}
2643

    
2644
static int opt_audio_rate(const char *opt, const char *arg)
2645
{
2646
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2647
    return 0;
2648
}
2649

    
2650
static int opt_audio_channels(const char *opt, const char *arg)
2651
{
2652
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2653
    return 0;
2654
}
2655

    
2656
static void opt_video_channel(const char *arg)
2657
{
2658
    video_channel = strtol(arg, NULL, 0);
2659
}
2660

    
2661
static void opt_video_standard(const char *arg)
2662
{
2663
    video_standard = av_strdup(arg);
2664
}
2665

    
2666
static void opt_codec(int *pstream_copy, char **pcodec_name,
2667
                      int codec_type, const char *arg)
2668
{
2669
    av_freep(pcodec_name);
2670
    if (!strcmp(arg, "copy")) {
2671
        *pstream_copy = 1;
2672
    } else {
2673
        *pcodec_name = av_strdup(arg);
2674
    }
2675
}
2676

    
2677
static void opt_audio_codec(const char *arg)
2678
{
2679
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2680
}
2681

    
2682
static void opt_audio_tag(const char *arg)
2683
{
2684
    char *tail;
2685
    audio_codec_tag= strtol(arg, &tail, 0);
2686

    
2687
    if(!tail || *tail)
2688
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2689
}
2690

    
2691
static void opt_video_tag(const char *arg)
2692
{
2693
    char *tail;
2694
    video_codec_tag= strtol(arg, &tail, 0);
2695

    
2696
    if(!tail || *tail)
2697
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2698
}
2699

    
2700
static void opt_video_codec(const char *arg)
2701
{
2702
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2703
}
2704

    
2705
static void opt_subtitle_codec(const char *arg)
2706
{
2707
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2708
}
2709

    
2710
static void opt_subtitle_tag(const char *arg)
2711
{
2712
    char *tail;
2713
    subtitle_codec_tag= strtol(arg, &tail, 0);
2714

    
2715
    if(!tail || *tail)
2716
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2717
}
2718

    
2719
static void opt_map(const char *arg)
2720
{
2721
    AVStreamMap *m;
2722
    char *p;
2723

    
2724
    m = &stream_maps[nb_stream_maps++];
2725

    
2726
    m->file_index = strtol(arg, &p, 0);
2727
    if (*p)
2728
        p++;
2729

    
2730
    m->stream_index = strtol(p, &p, 0);
2731
    if (*p) {
2732
        p++;
2733
        m->sync_file_index = strtol(p, &p, 0);
2734
        if (*p)
2735
            p++;
2736
        m->sync_stream_index = strtol(p, &p, 0);
2737
    } else {
2738
        m->sync_file_index = m->file_index;
2739
        m->sync_stream_index = m->stream_index;
2740
    }
2741
}
2742

    
2743
static void opt_map_meta_data(const char *arg)
2744
{
2745
    AVMetaDataMap *m;
2746
    char *p;
2747

    
2748
    m = &meta_data_maps[nb_meta_data_maps++];
2749

    
2750
    m->out_file = strtol(arg, &p, 0);
2751
    if (*p)
2752
        p++;
2753

    
2754
    m->in_file = strtol(p, &p, 0);
2755
}
2756

    
2757
static void opt_input_ts_scale(const char *arg)
2758
{
2759
    unsigned int stream;
2760
    double scale;
2761
    char *p;
2762

    
2763
    stream = strtol(arg, &p, 0);
2764
    if (*p)
2765
        p++;
2766
    scale= strtod(p, &p);
2767

    
2768
    if(stream >= MAX_STREAMS)
2769
        av_exit(1);
2770

    
2771
    input_files_ts_scale[nb_input_files][stream]= scale;
2772
}
2773

    
2774
static int opt_recording_time(const char *opt, const char *arg)
2775
{
2776
    recording_time = parse_time_or_die(opt, arg, 1);
2777
    return 0;
2778
}
2779

    
2780
static int opt_start_time(const char *opt, const char *arg)
2781
{
2782
    start_time = parse_time_or_die(opt, arg, 1);
2783
    return 0;
2784
}
2785

    
2786
static int opt_rec_timestamp(const char *opt, const char *arg)
2787
{
2788
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2789
    return 0;
2790
}
2791

    
2792
static int opt_input_ts_offset(const char *opt, const char *arg)
2793
{
2794
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2795
    return 0;
2796
}
2797

    
2798
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2799
{
2800
    const char *codec_string = encoder ? "encoder" : "decoder";
2801
    AVCodec *codec;
2802

    
2803
    if(!name)
2804
        return CODEC_ID_NONE;
2805
    codec = encoder ?
2806
        avcodec_find_encoder_by_name(name) :
2807
        avcodec_find_decoder_by_name(name);
2808
    if(!codec) {
2809
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2810
        av_exit(1);
2811
    }
2812
    if(codec->type != type) {
2813
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2814
        av_exit(1);
2815
    }
2816
    return codec->id;
2817
}
2818

    
2819
static void opt_input_file(const char *filename)
2820
{
2821
    AVFormatContext *ic;
2822
    AVFormatParameters params, *ap = &params;
2823
    int err, i, ret, rfps, rfps_base;
2824
    int64_t timestamp;
2825

    
2826
    if (!strcmp(filename, "-"))
2827
        filename = "pipe:";
2828

    
2829
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2830
                    !strcmp(filename, "/dev/stdin");
2831

    
2832
    /* get default parameters from command line */
2833
    ic = avformat_alloc_context();
2834

    
2835
    memset(ap, 0, sizeof(*ap));
2836
    ap->prealloced_context = 1;
2837
    ap->sample_rate = audio_sample_rate;
2838
    ap->channels = audio_channels;
2839
    ap->time_base.den = frame_rate.num;
2840
    ap->time_base.num = frame_rate.den;
2841
    ap->width = frame_width + frame_padleft + frame_padright;
2842
    ap->height = frame_height + frame_padtop + frame_padbottom;
2843
    ap->pix_fmt = frame_pix_fmt;
2844
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2845
    ap->channel = video_channel;
2846
    ap->standard = video_standard;
2847
    ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2848
    ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2849
    if(pgmyuv_compatibility_hack)
2850
        ap->video_codec_id= CODEC_ID_PGMYUV;
2851

    
2852
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2853

    
2854
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2855
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2856
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2857
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2858

    
2859
    /* open the input file with generic libav function */
2860
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2861
    if (err < 0) {
2862
        print_error(filename, err);
2863
        av_exit(1);
2864
    }
2865
    if(opt_programid) {
2866
        int i;
2867
        for(i=0; i<ic->nb_programs; i++)
2868
            if(ic->programs[i]->id != opt_programid)
2869
                ic->programs[i]->discard = AVDISCARD_ALL;
2870
    }
2871

    
2872
    ic->loop_input = loop_input;
2873

    
2874
    /* If not enough info to get the stream parameters, we decode the
2875
       first frames to get it. (used in mpeg case for example) */
2876
    ret = av_find_stream_info(ic);
2877
    if (ret < 0 && verbose >= 0) {
2878
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2879
        av_exit(1);
2880
    }
2881

    
2882
    timestamp = start_time;
2883
    /* add the stream start time */
2884
    if (ic->start_time != AV_NOPTS_VALUE)
2885
        timestamp += ic->start_time;
2886

    
2887
    /* if seeking requested, we execute it */
2888
    if (start_time != 0) {
2889
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2890
        if (ret < 0) {
2891
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2892
                    filename, (double)timestamp / AV_TIME_BASE);
2893
        }
2894
        /* reset seek info */
2895
        start_time = 0;
2896
    }
2897

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

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

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

    
2938
                    (float)rfps / rfps_base, rfps, rfps_base);
2939
            }
2940
            /* update the current frame rate to match the stream frame rate */
2941
            frame_rate.num = rfps;
2942
            frame_rate.den = rfps_base;
2943

    
2944
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2945
            if(video_disable)
2946
                ic->streams[i]->discard= AVDISCARD_ALL;
2947
            else if(video_discard)
2948
                ic->streams[i]->discard= video_discard;
2949
            break;
2950
        case CODEC_TYPE_DATA:
2951
            break;
2952
        case CODEC_TYPE_SUBTITLE:
2953
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2954
            if(subtitle_disable)
2955
                ic->streams[i]->discard = AVDISCARD_ALL;
2956
            break;
2957
        case CODEC_TYPE_ATTACHMENT:
2958
        case CODEC_TYPE_UNKNOWN:
2959
            nb_icodecs++;
2960
            break;
2961
        default:
2962
            abort();
2963
        }
2964
    }
2965

    
2966
    input_files[nb_input_files] = ic;
2967
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2968
    /* dump the file content */
2969
    if (verbose >= 0)
2970
        dump_format(ic, nb_input_files, filename, 0);
2971

    
2972
    nb_input_files++;
2973
    file_iformat = NULL;
2974
    file_oformat = NULL;
2975

    
2976
    video_channel = 0;
2977

    
2978
    av_freep(&video_codec_name);
2979
    av_freep(&audio_codec_name);
2980
    av_freep(&subtitle_codec_name);
2981
}
2982

    
2983
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2984
                                         int *has_subtitle_ptr)
2985
{
2986
    int has_video, has_audio, has_subtitle, i, j;
2987
    AVFormatContext *ic;
2988

    
2989
    has_video = 0;
2990
    has_audio = 0;
2991
    has_subtitle = 0;
2992
    for(j=0;j<nb_input_files;j++) {
2993
        ic = input_files[j];
2994
        for(i=0;i<ic->nb_streams;i++) {
2995
            AVCodecContext *enc = ic->streams[i]->codec;
2996
            switch(enc->codec_type) {
2997
            case CODEC_TYPE_AUDIO:
2998
                has_audio = 1;
2999
                break;
3000
            case CODEC_TYPE_VIDEO:
3001
                has_video = 1;
3002
                break;
3003
            case CODEC_TYPE_SUBTITLE:
3004
                has_subtitle = 1;
3005
                break;
3006
            case CODEC_TYPE_DATA:
3007
            case CODEC_TYPE_ATTACHMENT:
3008
            case CODEC_TYPE_UNKNOWN:
3009
                break;
3010
            default:
3011
                abort();
3012
            }
3013
        }
3014
    }
3015
    *has_video_ptr = has_video;
3016
    *has_audio_ptr = has_audio;
3017
    *has_subtitle_ptr = has_subtitle;
3018
}
3019

    
3020
static void new_video_stream(AVFormatContext *oc)
3021
{
3022
    AVStream *st;
3023
    AVCodecContext *video_enc;
3024
    int codec_id;
3025

    
3026
    st = av_new_stream(oc, oc->nb_streams);
3027
    if (!st) {
3028
        fprintf(stderr, "Could not alloc stream\n");
3029
        av_exit(1);
3030
    }
3031
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3032
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3033
    video_bitstream_filters= NULL;
3034

    
3035
    if(thread_count>1)
3036
        avcodec_thread_init(st->codec, thread_count);
3037

    
3038
    video_enc = st->codec;
3039

    
3040
    if(video_codec_tag)
3041
        video_enc->codec_tag= video_codec_tag;
3042

    
3043
    if(   (video_global_header&1)
3044
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3045
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3046
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3047
    }
3048
    if(video_global_header&2){
3049
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3050
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3051
    }
3052

    
3053
    if (video_stream_copy) {
3054
        st->stream_copy = 1;
3055
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3056
        video_enc->sample_aspect_ratio =
3057
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3058
    } else {
3059
        const char *p;
3060
        int i;
3061
        AVCodec *codec;
3062
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3063

    
3064
        if (video_codec_name) {
3065
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3066
            codec = avcodec_find_encoder_by_name(video_codec_name);
3067
            output_codecs[nb_ocodecs] = codec;
3068
        } else {
3069
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3070
            codec = avcodec_find_encoder(codec_id);
3071
        }
3072

    
3073
        video_enc->codec_id = codec_id;
3074

    
3075
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3076

    
3077
        if (codec && codec->supported_framerates && !force_fps)
3078
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3079
        video_enc->time_base.den = fps.num;
3080
        video_enc->time_base.num = fps.den;
3081

    
3082
        video_enc->width = frame_width + frame_padright + frame_padleft;
3083
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3084
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3085
        video_enc->pix_fmt = frame_pix_fmt;
3086
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3087

    
3088
        if(codec && codec->pix_fmts){
3089
            const enum PixelFormat *p= codec->pix_fmts;
3090
            for(; *p!=-1; p++){
3091
                if(*p == video_enc->pix_fmt)
3092
                    break;
3093
            }
3094
            if(*p == -1)
3095
                video_enc->pix_fmt = codec->pix_fmts[0];
3096
        }
3097

    
3098
        if (intra_only)
3099
            video_enc->gop_size = 0;
3100
        if (video_qscale || same_quality) {
3101
            video_enc->flags |= CODEC_FLAG_QSCALE;
3102
            video_enc->global_quality=
3103
                st->quality = FF_QP2LAMBDA * video_qscale;
3104
        }
3105

    
3106
        if(intra_matrix)
3107
            video_enc->intra_matrix = intra_matrix;
3108
        if(inter_matrix)
3109
            video_enc->inter_matrix = inter_matrix;
3110

    
3111
        video_enc->thread_count = thread_count;
3112
        p= video_rc_override_string;
3113
        for(i=0; p; i++){
3114
            int start, end, q;
3115
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3116
            if(e!=3){
3117
                fprintf(stderr, "error parsing rc_override\n");
3118
                av_exit(1);
3119
            }
3120
            video_enc->rc_override=
3121
                av_realloc(video_enc->rc_override,
3122
                           sizeof(RcOverride)*(i+1));
3123
            video_enc->rc_override[i].start_frame= start;
3124
            video_enc->rc_override[i].end_frame  = end;
3125
            if(q>0){
3126
                video_enc->rc_override[i].qscale= q;
3127
                video_enc->rc_override[i].quality_factor= 1.0;
3128
            }
3129
            else{
3130
                video_enc->rc_override[i].qscale= 0;
3131
                video_enc->rc_override[i].quality_factor= -q/100.0;
3132
            }
3133
            p= strchr(p, '/');
3134
            if(p) p++;
3135
        }
3136
        video_enc->rc_override_count=i;
3137
        if (!video_enc->rc_initial_buffer_occupancy)
3138
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3139
        video_enc->me_threshold= me_threshold;
3140
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3141

    
3142
        if (do_psnr)
3143
            video_enc->flags|= CODEC_FLAG_PSNR;
3144

    
3145
        /* two pass mode */
3146
        if (do_pass) {
3147
            if (do_pass == 1) {
3148
                video_enc->flags |= CODEC_FLAG_PASS1;
3149
            } else {
3150
                video_enc->flags |= CODEC_FLAG_PASS2;
3151
            }
3152
        }
3153
    }
3154
    nb_ocodecs++;
3155

    
3156
    /* reset some key parameters */
3157
    video_disable = 0;
3158
    av_freep(&video_codec_name);
3159
    video_stream_copy = 0;
3160
}
3161

    
3162
static void new_audio_stream(AVFormatContext *oc)
3163
{
3164
    AVStream *st;
3165
    AVCodecContext *audio_enc;
3166
    int codec_id;
3167

    
3168
    st = av_new_stream(oc, oc->nb_streams);
3169
    if (!st) {
3170
        fprintf(stderr, "Could not alloc stream\n");
3171
        av_exit(1);
3172
    }
3173
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3174

    
3175
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3176
    audio_bitstream_filters= NULL;
3177

    
3178
    if(thread_count>1)
3179
        avcodec_thread_init(st->codec, thread_count);
3180

    
3181
    audio_enc = st->codec;
3182
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3183

    
3184
    if(audio_codec_tag)
3185
        audio_enc->codec_tag= audio_codec_tag;
3186

    
3187
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3188
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3189
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3190
    }
3191
    if (audio_stream_copy) {
3192
        st->stream_copy = 1;
3193
        audio_enc->channels = audio_channels;
3194
    } else {
3195
        AVCodec *codec;
3196

    
3197
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3198

    
3199
        if (audio_codec_name) {
3200
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3201
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3202
            output_codecs[nb_ocodecs] = codec;
3203
        } else {
3204
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3205
            codec = avcodec_find_encoder(codec_id);
3206
        }
3207
        audio_enc->codec_id = codec_id;
3208

    
3209
        if (audio_qscale > QSCALE_NONE) {
3210
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3211
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3212
        }
3213
        audio_enc->thread_count = thread_count;
3214
        audio_enc->channels = audio_channels;
3215
        audio_enc->sample_fmt = audio_sample_fmt;
3216
        audio_enc->channel_layout = channel_layout;
3217

    
3218
        if(codec && codec->sample_fmts){
3219
            const enum SampleFormat *p= codec->sample_fmts;
3220
            for(; *p!=-1; p++){
3221
                if(*p == audio_enc->sample_fmt)
3222
                    break;
3223
            }
3224
            if(*p == -1)
3225
                audio_enc->sample_fmt = codec->sample_fmts[0];
3226
        }
3227
    }
3228
    nb_ocodecs++;
3229
    audio_enc->sample_rate = audio_sample_rate;
3230
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3231
    if (audio_language) {
3232
        av_metadata_set(&st->metadata, "language", audio_language);
3233
        av_free(audio_language);
3234
        audio_language = NULL;
3235
    }
3236

    
3237
    /* reset some key parameters */
3238
    audio_disable = 0;
3239
    av_freep(&audio_codec_name);
3240
    audio_stream_copy = 0;
3241
}
3242

    
3243
static void new_subtitle_stream(AVFormatContext *oc)
3244
{
3245
    AVStream *st;
3246
    AVCodecContext *subtitle_enc;
3247

    
3248
    st = av_new_stream(oc, oc->nb_streams);
3249
    if (!st) {
3250
        fprintf(stderr, "Could not alloc stream\n");
3251
        av_exit(1);
3252
    }
3253
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3254

    
3255
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3256
    subtitle_bitstream_filters= NULL;
3257

    
3258
    subtitle_enc = st->codec;
3259
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3260

    
3261
    if(subtitle_codec_tag)
3262
        subtitle_enc->codec_tag= subtitle_codec_tag;
3263

    
3264
    if (subtitle_stream_copy) {
3265
        st->stream_copy = 1;
3266
    } else {
3267
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3268
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3269
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3270
    }
3271
    nb_ocodecs++;
3272

    
3273
    if (subtitle_language) {
3274
        av_metadata_set(&st->metadata, "language", subtitle_language);
3275
        av_free(subtitle_language);
3276
        subtitle_language = NULL;
3277
    }
3278

    
3279
    subtitle_disable = 0;
3280
    av_freep(&subtitle_codec_name);
3281
    subtitle_stream_copy = 0;
3282
}
3283

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

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

    
3306
static void opt_new_subtitle_stream(void)
3307
{
3308
    AVFormatContext *oc;
3309
    if (nb_output_files <= 0) {
3310
        fprintf(stderr, "At least one output file must be specified\n");
3311
        av_exit(1);
3312
    }
3313
    oc = output_files[nb_output_files - 1];
3314
    new_subtitle_stream(oc);
3315
}
3316

    
3317
static void opt_output_file(const char *filename)
3318
{
3319
    AVFormatContext *oc;
3320
    int use_video, use_audio, use_subtitle;
3321
    int input_has_video, input_has_audio, input_has_subtitle;
3322
    AVFormatParameters params, *ap = &params;
3323

    
3324
    if (!strcmp(filename, "-"))
3325
        filename = "pipe:";
3326

    
3327
    oc = avformat_alloc_context();
3328

    
3329
    if (!file_oformat) {
3330
        file_oformat = guess_format(NULL, filename, NULL);
3331
        if (!file_oformat) {
3332
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3333
                    filename);
3334
            av_exit(1);
3335
        }
3336
    }
3337

    
3338
    oc->oformat = file_oformat;
3339
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3340

    
3341
    if (!strcmp(file_oformat->name, "ffm") &&
3342
        av_strstart(filename, "http:", NULL)) {
3343
        /* special case for files sent to ffserver: we get the stream
3344
           parameters from ffserver */
3345
        int err = read_ffserver_streams(oc, filename);
3346
        if (err < 0) {
3347
            print_error(filename, err);
3348
            av_exit(1);
3349
        }
3350
    } else {
3351
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3352
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3353
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3354

    
3355
        /* disable if no corresponding type found and at least one
3356
           input file */
3357
        if (nb_input_files > 0) {
3358
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3359
                                         &input_has_subtitle);
3360
            if (!input_has_video)
3361
                use_video = 0;
3362
            if (!input_has_audio)
3363
                use_audio = 0;
3364
            if (!input_has_subtitle)
3365
                use_subtitle = 0;
3366
        }
3367

    
3368
        /* manual disable */
3369
        if (audio_disable) {
3370
            use_audio = 0;
3371
        }
3372
        if (video_disable) {
3373
            use_video = 0;
3374
        }
3375
        if (subtitle_disable) {
3376
            use_subtitle = 0;
3377
        }
3378

    
3379
        if (use_video) {
3380
            new_video_stream(oc);
3381
        }
3382

    
3383
        if (use_audio) {
3384
            new_audio_stream(oc);
3385
        }
3386

    
3387
        if (use_subtitle) {
3388
            new_subtitle_stream(oc);
3389
        }
3390

    
3391
        oc->timestamp = rec_timestamp;
3392

    
3393
        for(; metadata_count>0; metadata_count--){
3394
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3395
                                           metadata[metadata_count-1].value);
3396
        }
3397
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3398
    }
3399

    
3400
    output_files[nb_output_files++] = oc;
3401

    
3402
    /* check filename in case of an image number is expected */
3403
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3404
        if (!av_filename_number_test(oc->filename)) {
3405
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3406
            av_exit(1);
3407
        }
3408
    }
3409

    
3410
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3411
        /* test if it already exists to avoid loosing precious files */
3412
        if (!file_overwrite &&
3413
            (strchr(filename, ':') == NULL ||
3414
             filename[1] == ':' ||
3415
             av_strstart(filename, "file:", NULL))) {
3416
            if (url_exist(filename)) {
3417
                if (!using_stdin) {
3418
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3419
                    fflush(stderr);
3420
                    if (!read_yesno()) {
3421
                        fprintf(stderr, "Not overwriting - exiting\n");
3422
                        av_exit(1);
3423
                    }
3424
                }
3425
                else {
3426
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3427
                    av_exit(1);
3428
                }
3429
            }
3430
        }
3431

    
3432
        /* open the file */
3433
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3434
            fprintf(stderr, "Could not open '%s'\n", filename);
3435
            av_exit(1);
3436
        }
3437
    }
3438

    
3439
    memset(ap, 0, sizeof(*ap));
3440
    if (av_set_parameters(oc, ap) < 0) {
3441
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3442
                oc->filename);
3443
        av_exit(1);
3444
    }
3445

    
3446
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3447
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3448
    oc->loop_output = loop_output;
3449
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3450

    
3451
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3452

    
3453
    /* reset some options */
3454
    file_oformat = NULL;
3455
    file_iformat = NULL;
3456
}
3457

    
3458
/* same option as mencoder */
3459
static void opt_pass(const char *pass_str)
3460
{
3461
    int pass;
3462
    pass = atoi(pass_str);
3463
    if (pass != 1 && pass != 2) {
3464
        fprintf(stderr, "pass number can be only 1 or 2\n");
3465
        av_exit(1);
3466
    }
3467
    do_pass = pass;
3468
}
3469

    
3470
static int64_t getutime(void)
3471
{
3472
#if HAVE_GETRUSAGE
3473
    struct rusage rusage;
3474

    
3475
    getrusage(RUSAGE_SELF, &rusage);
3476
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3477
#elif HAVE_GETPROCESSTIMES
3478
    HANDLE proc;
3479
    FILETIME c, e, k, u;
3480
    proc = GetCurrentProcess();
3481
    GetProcessTimes(proc, &c, &e, &k, &u);
3482
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3483
#else
3484
    return av_gettime();
3485
#endif
3486
}
3487

    
3488
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3489
{
3490
    int i;
3491
    const char *p = str;
3492
    for(i = 0;; i++) {
3493
        dest[i] = atoi(p);
3494
        if(i == 63)
3495
            break;
3496
        p = strchr(p, ',');
3497
        if(!p) {
3498
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3499
            av_exit(1);
3500
        }
3501
        p++;
3502
    }
3503
}
3504

    
3505
static void opt_inter_matrix(const char *arg)
3506
{
3507
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3508
    parse_matrix_coeffs(inter_matrix, arg);
3509
}
3510

    
3511
static void opt_intra_matrix(const char *arg)
3512
{
3513
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3514
    parse_matrix_coeffs(intra_matrix, arg);
3515
}
3516

    
3517
/**
3518
 * Trivial log callback.
3519
 * Only suitable for show_help and similar since it lacks prefix handling.
3520
 */
3521
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3522
{
3523
    vfprintf(stdout, fmt, vl);
3524
}
3525

    
3526
static void show_help(void)
3527
{
3528
    av_log_set_callback(log_callback_help);
3529
    printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3530
           "Hyper fast Audio and Video encoder\n");
3531
    printf("\n");
3532
    show_help_options(options, "Main options:\n",
3533
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3534
    show_help_options(options, "\nAdvanced options:\n",
3535
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3536
                      OPT_EXPERT);
3537
    show_help_options(options, "\nVideo options:\n",
3538
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3539
                      OPT_VIDEO);
3540
    show_help_options(options, "\nAdvanced Video options:\n",
3541
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3542
                      OPT_VIDEO | OPT_EXPERT);
3543
    show_help_options(options, "\nAudio options:\n",
3544
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3545
                      OPT_AUDIO);
3546
    show_help_options(options, "\nAdvanced Audio options:\n",
3547
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3548
                      OPT_AUDIO | OPT_EXPERT);
3549
    show_help_options(options, "\nSubtitle options:\n",
3550
                      OPT_SUBTITLE | OPT_GRAB,
3551
                      OPT_SUBTITLE);
3552
    show_help_options(options, "\nAudio/Video grab options:\n",
3553
                      OPT_GRAB,
3554
                      OPT_GRAB);
3555
    printf("\n");
3556
    av_opt_show(avcodec_opts[0], NULL);
3557
    printf("\n");
3558
    av_opt_show(avformat_opts, NULL);
3559
    printf("\n");
3560
    av_opt_show(sws_opts, NULL);
3561
}
3562

    
3563
static void opt_target(const char *arg)
3564
{
3565
    int norm = -1;
3566
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3567

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

    
3612
    if(norm < 0) {
3613
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3614
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3615
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3616
        av_exit(1);
3617
    }
3618

    
3619
    if(!strcmp(arg, "vcd")) {
3620

    
3621
        opt_video_codec("mpeg1video");
3622
        opt_audio_codec("mp2");
3623
        opt_format("vcd");
3624

    
3625
        opt_frame_size(norm ? "352x240" : "352x288");
3626
        opt_frame_rate(NULL, frame_rates[norm]);
3627
        opt_default("gop", norm ? "18" : "15");
3628

    
3629
        opt_default("b", "1150000");
3630
        opt_default("maxrate", "1150000");
3631
        opt_default("minrate", "1150000");
3632
        opt_default("bufsize", "327680"); // 40*1024*8;
3633

    
3634
        opt_default("ab", "224000");
3635
        audio_sample_rate = 44100;
3636
        audio_channels = 2;
3637

    
3638
        opt_default("packetsize", "2324");
3639
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3640

    
3641
        /* We have to offset the PTS, so that it is consistent with the SCR.
3642
           SCR starts at 36000, but the first two packs contain only padding
3643
           and the first pack from the other stream, respectively, may also have
3644
           been written before.
3645
           So the real data starts at SCR 36000+3*1200. */
3646
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3647
    } else if(!strcmp(arg, "svcd")) {
3648

    
3649
        opt_video_codec("mpeg2video");
3650
        opt_audio_codec("mp2");
3651
        opt_format("svcd");
3652

    
3653
        opt_frame_size(norm ? "480x480" : "480x576");
3654
        opt_frame_rate(NULL, frame_rates[norm]);
3655
        opt_default("gop", norm ? "18" : "15");
3656

    
3657
        opt_default("b", "2040000");
3658
        opt_default("maxrate", "2516000");
3659
        opt_default("minrate", "0"); //1145000;
3660
        opt_default("bufsize", "1835008"); //224*1024*8;
3661
        opt_default("flags", "+scan_offset");
3662

    
3663

    
3664
        opt_default("ab", "224000");
3665
        audio_sample_rate = 44100;
3666

    
3667
        opt_default("packetsize", "2324");
3668

    
3669
    } else if(!strcmp(arg, "dvd")) {
3670

    
3671
        opt_video_codec("mpeg2video");
3672
        opt_audio_codec("ac3");
3673
        opt_format("dvd");
3674

    
3675
        opt_frame_size(norm ? "720x480" : "720x576");
3676
        opt_frame_rate(NULL, frame_rates[norm]);
3677
        opt_default("gop", norm ? "18" : "15");
3678

    
3679
        opt_default("b", "6000000");
3680
        opt_default("maxrate", "9000000");
3681
        opt_default("minrate", "0"); //1500000;
3682
        opt_default("bufsize", "1835008"); //224*1024*8;
3683

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

    
3687
        opt_default("ab", "448000");
3688
        audio_sample_rate = 48000;
3689

    
3690
    } else if(!strncmp(arg, "dv", 2)) {
3691

    
3692
        opt_format("dv");
3693

    
3694
        opt_frame_size(norm ? "720x480" : "720x576");
3695
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3696
                                             (norm ? "yuv411p" : "yuv420p"));
3697
        opt_frame_rate(NULL, frame_rates[norm]);
3698

    
3699
        audio_sample_rate = 48000;
3700
        audio_channels = 2;
3701

    
3702
    } else {
3703
        fprintf(stderr, "Unknown target: %s\n", arg);
3704
        av_exit(1);
3705
    }
3706
}
3707

    
3708
static void opt_vstats_file (const char *arg)
3709
{
3710
    av_free (vstats_filename);
3711
    vstats_filename=av_strdup (arg);
3712
}
3713

    
3714
static void opt_vstats (void)
3715
{
3716
    char filename[40];
3717
    time_t today2 = time(NULL);
3718
    struct tm *today = localtime(&today2);
3719

    
3720
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3721
             today->tm_sec);
3722
    opt_vstats_file(filename);
3723
}
3724

    
3725
static int opt_bsf(const char *opt, const char *arg)
3726
{
3727
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3728
    AVBitStreamFilterContext **bsfp;
3729

    
3730
    if(!bsfc){
3731
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3732
        av_exit(1);
3733
    }
3734

    
3735
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3736
          *opt == 'a' ? &audio_bitstream_filters :
3737
                        &subtitle_bitstream_filters;
3738
    while(*bsfp)
3739
        bsfp= &(*bsfp)->next;
3740

    
3741
    *bsfp= bsfc;
3742

    
3743
    return 0;
3744
}
3745

    
3746
static int opt_preset(const char *opt, const char *arg)
3747
{
3748
    FILE *f=NULL;
3749
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3750
    int i;
3751
    const char *base[2]= { getenv("HOME"),
3752
                           FFMPEG_DATADIR,
3753
                         };
3754

    
3755
    for(i=!base[0]; i<2 && !f; i++){
3756
        snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3757
        f= fopen(filename, "r");
3758
        if(!f){
3759
            char *codec_name= *opt == 'v' ? video_codec_name :
3760
                              *opt == 'a' ? audio_codec_name :
3761
                                            subtitle_codec_name;
3762
            snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3763
            f= fopen(filename, "r");
3764
        }
3765
    }
3766
    if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3767
              is_dos_path(arg))){
3768
        av_strlcpy(filename, arg, sizeof(filename));
3769
        f= fopen(filename, "r");
3770
    }
3771

    
3772
    if(!f){
3773
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3774
        av_exit(1);
3775
    }
3776

    
3777
    while(!feof(f)){
3778
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3779
        if(line[0] == '#' && !e)
3780
            continue;
3781
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3782
        if(e){
3783
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3784
            av_exit(1);
3785
        }
3786
        if(!strcmp(tmp, "acodec")){
3787
            opt_audio_codec(tmp2);
3788
        }else if(!strcmp(tmp, "vcodec")){
3789
            opt_video_codec(tmp2);
3790
        }else if(!strcmp(tmp, "scodec")){
3791
            opt_subtitle_codec(tmp2);
3792
        }else if(opt_default(tmp, tmp2) < 0){
3793
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3794
            av_exit(1);
3795
        }
3796
    }
3797

    
3798
    fclose(f);
3799

    
3800
    return 0;
3801
}
3802

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

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

    
3888
    /* audio options */
3889
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3890
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3891
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3892
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3893
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3894
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3895
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3896
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3897
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3898
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3899
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3900
    { "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" },
3901

    
3902
    /* subtitle options */
3903
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3904
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3905
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3906
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3907
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3908

    
3909
    /* grab options */
3910
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3911
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3912
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3913

    
3914
    /* muxer options */
3915
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3916
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3917

    
3918
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3919
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3920
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3921

    
3922
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3923
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3924
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3925

    
3926
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3927
    { NULL, },
3928
};
3929

    
3930
int main(int argc, char **argv)
3931
{
3932
    int i;
3933
    int64_t ti;
3934

    
3935
    avcodec_register_all();
3936
    avdevice_register_all();
3937
    av_register_all();
3938

    
3939
    if(isatty(STDIN_FILENO))
3940
        url_set_interrupt_cb(decode_interrupt_cb);
3941

    
3942
    for(i=0; i<CODEC_TYPE_NB; i++){
3943
        avcodec_opts[i]= avcodec_alloc_context2(i);
3944
    }
3945
    avformat_opts = avformat_alloc_context();
3946
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3947

    
3948
    show_banner();
3949

    
3950
    /* parse options */
3951
    parse_options(argc, argv, options, opt_output_file);
3952

    
3953
    /* file converter / grab */
3954
    if (nb_output_files <= 0) {
3955
        fprintf(stderr, "At least one output file must be specified\n");
3956
        av_exit(1);
3957
    }
3958

    
3959
    if (nb_input_files == 0) {
3960
        fprintf(stderr, "At least one input file must be specified\n");
3961
        av_exit(1);
3962
    }
3963

    
3964
    ti = getutime();
3965
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3966
                  stream_maps, nb_stream_maps) < 0)
3967
        av_exit(1);
3968
    ti = getutime() - ti;
3969
    if (do_benchmark) {
3970
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3971
    }
3972

    
3973
    return av_exit(0);
3974
}