Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ b5ee9c23

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;
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
        enc = ost->st->codec;
1098
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1099
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1100
                     !ost->st->stream_copy ?
1101
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1102
        }
1103
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1104
            float t = (av_gettime()-timer_start) / 1000000.0;
1105

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

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

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

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

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

    
1166
        fflush(stderr);
1167
    }
1168

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1379
                        av_init_packet(&opkt);
1380

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

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

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

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

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

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

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

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

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

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

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

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

    
1461
                        switch(ost->st->codec->codec_type) {
1462
                        case CODEC_TYPE_AUDIO:
1463
                            fifo_bytes = av_fifo_size(ost->fifo);
1464
                            ret = 0;
1465
                            /* encode any samples remaining in fifo */
1466
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1467
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1468
                                int fs_tmp = enc->frame_size;
1469
                                enc->frame_size = fifo_bytes / (osize * 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
    timer_start = av_gettime();
2067

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2206
    discard_packet:
2207
        av_free_packet(&pkt);
2208

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

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

    
2221
    term_exit();
2222

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2364
    opt_default(opt, arg);
2365

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

    
2369
    return 0;
2370
}
2371

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

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

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

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

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

    
2456

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

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

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

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

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

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

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

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

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

    
2514

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

    
2528

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

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

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

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

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

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

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

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

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

    
2605
    return 0;
2606
}
2607

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2851
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2852

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

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

    
2871
    ic->loop_input = loop_input;
2872

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

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

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

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

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

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

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

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

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

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

    
2975
    video_channel = 0;
2976

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

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

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

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

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

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

    
3037
    video_enc = st->codec;
3038

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

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

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

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

    
3072
        video_enc->codec_id = codec_id;
3073

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3326
    oc = avformat_alloc_context();
3327

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

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

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

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

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

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

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

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

    
3390
        oc->timestamp = rec_timestamp;
3391

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

    
3399
    output_files[nb_output_files++] = oc;
3400

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

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

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

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

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

    
3450
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3451

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3662

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

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

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

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

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

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

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

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

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

    
3691
        opt_format("dv");
3692

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

    
3698
        audio_sample_rate = 48000;
3699
        audio_channels = 2;
3700

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

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

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

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

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

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

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

    
3740
    *bsfp= bsfc;
3741

    
3742
    return 0;
3743
}
3744

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

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

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

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

    
3797
    fclose(f);
3798

    
3799
    return 0;
3800
}
3801

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3947
    show_banner();
3948

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

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

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

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

    
3972
    return av_exit(0);
3973
}