Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 22c4c3e0

History | View | Annotate | Download (141 KB)

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

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

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

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

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

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

    
65
#include "cmdutils.h"
66

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

    
70
#undef exit
71

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

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

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

    
89
static const OptionDef options[];
90

    
91
#define MAX_FILES 20
92

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

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

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

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

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

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

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

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

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

    
197
static int rate_emu = 0;
198

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

    
202
static int audio_volume = 256;
203

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

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

    
221
static unsigned int sws_flags = SWS_BICUBIC;
222

    
223
static int64_t timer_start;
224

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

    
229
static short *samples;
230

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

    
236
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
237

    
238
struct AVInputStream;
239

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

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

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

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

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

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

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

    
299
#if HAVE_TERMIOS_H
300

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

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

    
312
static volatile sig_atomic_t received_sigterm = 0;
313

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
423
    av_free(opt_names);
424

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

    
429
    av_free(video_standard);
430

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
527
        bsfc= bsfc->next;
528
    }
529

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

    
537
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
538

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
863
    *frame_size = 0;
864

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1085

    
1086
    oc = output_files[0];
1087

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

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

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

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

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

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

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

    
1167
        fflush(stderr);
1168
    }
1169

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1380
                        av_init_packet(&opkt);
1381

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

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

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

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

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

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

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

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

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

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

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

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

    
1462
                        switch(ost->st->codec->codec_type) {
1463
                        case CODEC_TYPE_AUDIO:
1464
                            fifo_bytes = av_fifo_size(ost->fifo);
1465
                            ret = 0;
1466
                            /* encode any samples remaining in fifo */
1467
                            if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1468
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1469
                                int fs_tmp = enc->frame_size;
1470
                                enc->frame_size = fifo_bytes / (osize * enc->channels);
1471
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1472
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1473
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1474
                                                          ost->st->time_base.num, enc->sample_rate);
1475
                                enc->frame_size = fs_tmp;
1476
                            }
1477
                            if(ret <= 0) {
1478
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1479
                            }
1480
                            if (ret < 0) {
1481
                                fprintf(stderr, "Audio encoding failed\n");
1482
                                av_exit(1);
1483
                            }
1484
                            audio_size += ret;
1485
                            pkt.flags |= PKT_FLAG_KEY;
1486
                            break;
1487
                        case CODEC_TYPE_VIDEO:
1488
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1489
                            if (ret < 0) {
1490
                                fprintf(stderr, "Video encoding failed\n");
1491
                                av_exit(1);
1492
                            }
1493
                            video_size += ret;
1494
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1495
                                pkt.flags |= PKT_FLAG_KEY;
1496
                            if (ost->logfile && enc->stats_out) {
1497
                                fprintf(ost->logfile, "%s", enc->stats_out);
1498
                            }
1499
                            break;
1500
                        default:
1501
                            ret=-1;
1502
                        }
1503

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

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

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

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

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

    
1554
    return -1;
1555
}
1556

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2006

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2208
    discard_packet:
2209
        av_free_packet(&pkt);
2210

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

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

    
2223
    term_exit();
2224

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2366
    opt_default(opt, arg);
2367

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

    
2371
    return 0;
2372
}
2373

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

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

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

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

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

    
2458

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

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

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

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

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

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

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

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

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

    
2516

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

    
2530

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

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

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

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

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

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

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

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

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

    
2607
    return 0;
2608
}
2609

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2853
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2854

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

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

    
2873
    ic->loop_input = loop_input;
2874

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

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

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

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

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

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

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

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

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

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

    
2977
    video_channel = 0;
2978

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

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

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

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

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

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

    
3039
    video_enc = st->codec;
3040

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

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

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

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

    
3074
        video_enc->codec_id = codec_id;
3075

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3328
    oc = avformat_alloc_context();
3329

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

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

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

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

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

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

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

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

    
3392
        oc->timestamp = rec_timestamp;
3393

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

    
3401
    output_files[nb_output_files++] = oc;
3402

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

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

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

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

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

    
3452
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3453

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3664

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

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

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

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

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

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

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

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

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

    
3693
        opt_format("dv");
3694

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

    
3700
        audio_sample_rate = 48000;
3701
        audio_channels = 2;
3702

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

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

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

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

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

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

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

    
3742
    *bsfp= bsfc;
3743

    
3744
    return 0;
3745
}
3746

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

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

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

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

    
3799
    fclose(f);
3800

    
3801
    return 0;
3802
}
3803

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3949
    show_banner();
3950

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

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

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

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

    
3974
    return av_exit(0);
3975
}