Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ b10d7e4e

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

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

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

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

    
66
#include "cmdutils.h"
67

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

    
71
#undef exit
72

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

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

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

    
90
static const OptionDef options[];
91

    
92
#define MAX_FILES 20
93

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

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

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

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

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

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

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

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

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

    
198
static int rate_emu = 0;
199

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

    
203
static int audio_volume = 256;
204

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

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

    
222
static unsigned int sws_flags = SWS_BICUBIC;
223

    
224
static int64_t timer_start;
225

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

    
230
static short *samples;
231

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

    
237
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
238

    
239
struct AVInputStream;
240

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

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

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

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

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

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

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

    
300
#if HAVE_TERMIOS_H
301

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

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

    
313
static volatile sig_atomic_t received_sigterm = 0;
314

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
424
    av_free(opt_names);
425

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

    
430
    av_free(video_standard);
431

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
528
        bsfc= bsfc->next;
529
    }
530

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

    
538
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
539

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
864
    *frame_size = 0;
865

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1086

    
1087
    oc = output_files[0];
1088

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

    
1093
    buf[0] = '\0';
1094
    ti1 = 1e10;
1095
    vid = 0;
1096
    for(i=0;i<nb_ostreams;i++) {
1097
        ost = ost_table[i];
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) {
1468
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1469
                                int fs_tmp = enc->frame_size;
1470

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

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

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

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

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

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

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

    
1563
    return -1;
1564
}
1565

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1931
    if (!bit_buffer)
1932
        bit_buffer = av_malloc(bit_buffer_size);
1933
    if (!bit_buffer) {
1934
        ret = AVERROR(ENOMEM);
1935
        goto fail;
1936
    }
1937

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

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

    
1985
    /* init pts */
1986
    for(i=0;i<nb_istreams;i++) {
1987
        ist = ist_table[i];
1988
        ist->pts = 0;
1989
        ist->next_pts = AV_NOPTS_VALUE;
1990
        ist->is_start = 1;
1991
    }
1992

    
1993
    /* set meta data information from input file if required */
1994
    for (i=0;i<nb_meta_data_maps;i++) {
1995
        AVFormatContext *out_file;
1996
        AVFormatContext *in_file;
1997
        AVMetadataTag *mtag;
1998

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

    
2014
        out_file = output_files[out_file_index];
2015
        in_file = input_files[in_file_index];
2016

    
2017

    
2018
        mtag=NULL;
2019
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2020
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2021
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2022
                                    in_file->iformat->metadata_conv);
2023
    }
2024

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

    
2038
 dump_format:
2039
    /* dump the file output parameters - cannot be done before in case
2040
       of stream copy */
2041
    for(i=0;i<nb_output_files;i++) {
2042
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2043
    }
2044

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

    
2063
    if (ret) {
2064
        fprintf(stderr, "%s\n", error);
2065
        goto fail;
2066
    }
2067

    
2068
    if (want_sdp) {
2069
        print_sdp(output_files, nb_output_files);
2070
    }
2071

    
2072
    if (!using_stdin && verbose >= 0) {
2073
        fprintf(stderr, "Press [q] to stop encoding\n");
2074
        url_set_interrupt_cb(decode_interrupt_cb);
2075
    }
2076
    term_init();
2077

    
2078
    timer_start = av_gettime();
2079

    
2080
    for(; received_sigterm == 0;) {
2081
        int file_index, ist_index;
2082
        AVPacket pkt;
2083
        double ipts_min;
2084
        double opts_min;
2085

    
2086
    redo:
2087
        ipts_min= 1e100;
2088
        opts_min= 1e100;
2089
        /* if 'q' pressed, exits */
2090
        if (!using_stdin) {
2091
            if (q_pressed)
2092
                break;
2093
            /* read_key() returns 0 on EOF */
2094
            key = read_key();
2095
            if (key == 'q')
2096
                break;
2097
        }
2098

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

    
2140
        /* finish if recording time exhausted */
2141
        if (opts_min >= (recording_time / 1000000.0))
2142
            break;
2143

    
2144
        /* finish if limit size exhausted */
2145
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2146
            break;
2147

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

    
2164
        no_packet_count=0;
2165
        memset(no_packet, 0, sizeof(no_packet));
2166

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

    
2179
        if (pkt.dts != AV_NOPTS_VALUE)
2180
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2181
        if (pkt.pts != AV_NOPTS_VALUE)
2182
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2183

    
2184
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2185
            if(pkt.pts != AV_NOPTS_VALUE)
2186
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2187
            if(pkt.dts != AV_NOPTS_VALUE)
2188
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2189
        }
2190

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

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

    
2209
            if (verbose >= 0)
2210
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2211
                        ist->file_index, ist->index);
2212
            if (exit_on_error)
2213
                av_exit(1);
2214
            av_free_packet(&pkt);
2215
            goto redo;
2216
        }
2217

    
2218
    discard_packet:
2219
        av_free_packet(&pkt);
2220

    
2221
        /* dump report by using the output first video and audio streams */
2222
        print_report(output_files, ost_table, nb_ostreams, 0);
2223
    }
2224

    
2225
    /* at the end of stream, we must flush the decoder buffers */
2226
    for(i=0;i<nb_istreams;i++) {
2227
        ist = ist_table[i];
2228
        if (ist->decoding_needed) {
2229
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2230
        }
2231
    }
2232

    
2233
    term_exit();
2234

    
2235
    /* write the trailer if needed and close file */
2236
    for(i=0;i<nb_output_files;i++) {
2237
        os = output_files[i];
2238
        av_write_trailer(os);
2239
    }
2240

    
2241
    /* dump report by using the first video and audio streams */
2242
    print_report(output_files, ost_table, nb_ostreams, 1);
2243

    
2244
    /* close each encoder */
2245
    for(i=0;i<nb_ostreams;i++) {
2246
        ost = ost_table[i];
2247
        if (ost->encoding_needed) {
2248
            av_freep(&ost->st->codec->stats_in);
2249
            avcodec_close(ost->st->codec);
2250
        }
2251
    }
2252

    
2253
    /* close each decoder */
2254
    for(i=0;i<nb_istreams;i++) {
2255
        ist = ist_table[i];
2256
        if (ist->decoding_needed) {
2257
            avcodec_close(ist->st->codec);
2258
        }
2259
    }
2260

    
2261
    /* finished ! */
2262
    ret = 0;
2263

    
2264
 fail:
2265
    av_freep(&bit_buffer);
2266
    av_free(file_table);
2267

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

    
2300
#if 0
2301
int file_read(const char *filename)
2302
{
2303
    URLContext *h;
2304
    unsigned char buffer[1024];
2305
    int len, i;
2306

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

    
2322
static void opt_format(const char *arg)
2323
{
2324
    /* compatibility stuff for pgmyuv */
2325
    if (!strcmp(arg, "pgmyuv")) {
2326
        pgmyuv_compatibility_hack=1;
2327
//        opt_image_format(arg);
2328
        arg = "image2";
2329
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2330
    }
2331

    
2332
    file_iformat = av_find_input_format(arg);
2333
    file_oformat = guess_format(arg, NULL, NULL);
2334
    if (!file_iformat && !file_oformat) {
2335
        fprintf(stderr, "Unknown input or output format: %s\n", arg);
2336
        av_exit(1);
2337
    }
2338
}
2339

    
2340
static void opt_video_rc_override_string(const char *arg)
2341
{
2342
    video_rc_override_string = arg;
2343
}
2344

    
2345
static int opt_me_threshold(const char *opt, const char *arg)
2346
{
2347
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2348
    return 0;
2349
}
2350

    
2351
static int opt_loglevel(const char *opt, const char *arg)
2352
{
2353
    int level = parse_number_or_die(opt, arg, OPT_INT, INT_MIN, INT_MAX);
2354
    av_log_set_level(level);
2355
    return 0;
2356
}
2357

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

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

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

    
2377
    opt_default(opt, arg);
2378

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

    
2382
    return 0;
2383
}
2384

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

    
2403
static void opt_frame_crop_bottom(const char *arg)
2404
{
2405
    frame_bottomBand = atoi(arg);
2406
    if (frame_bottomBand < 0) {
2407
        fprintf(stderr, "Incorrect bottom crop size\n");
2408
        av_exit(1);
2409
    }
2410
    if ((frame_bottomBand % 2) != 0) {
2411
        fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2412
        av_exit(1);
2413
    }
2414
    if ((frame_bottomBand) >= frame_height){
2415
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2416
        av_exit(1);
2417
    }
2418
    frame_height -= frame_bottomBand;
2419
}
2420

    
2421
static void opt_frame_crop_left(const char *arg)
2422
{
2423
    frame_leftBand = atoi(arg);
2424
    if (frame_leftBand < 0) {
2425
        fprintf(stderr, "Incorrect left crop size\n");
2426
        av_exit(1);
2427
    }
2428
    if ((frame_leftBand % 2) != 0) {
2429
        fprintf(stderr, "Left crop size must be a multiple of 2\n");
2430
        av_exit(1);
2431
    }
2432
    if ((frame_leftBand) >= frame_width){
2433
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2434
        av_exit(1);
2435
    }
2436
    frame_width -= frame_leftBand;
2437
}
2438

    
2439
static void opt_frame_crop_right(const char *arg)
2440
{
2441
    frame_rightBand = atoi(arg);
2442
    if (frame_rightBand < 0) {
2443
        fprintf(stderr, "Incorrect right crop size\n");
2444
        av_exit(1);
2445
    }
2446
    if ((frame_rightBand % 2) != 0) {
2447
        fprintf(stderr, "Right crop size must be a multiple of 2\n");
2448
        av_exit(1);
2449
    }
2450
    if ((frame_rightBand) >= frame_width){
2451
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2452
        av_exit(1);
2453
    }
2454
    frame_width -= frame_rightBand;
2455
}
2456

    
2457
static void opt_frame_size(const char *arg)
2458
{
2459
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2460
        fprintf(stderr, "Incorrect frame size\n");
2461
        av_exit(1);
2462
    }
2463
    if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2464
        fprintf(stderr, "Frame size must be a multiple of 2\n");
2465
        av_exit(1);
2466
    }
2467
}
2468

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

    
2475
    r = (rgb >> 16);
2476
    g = ((rgb >> 8) & 255);
2477
    b = (rgb & 255);
2478

    
2479
    padcolor[0] = RGB_TO_Y(r,g,b);
2480
    padcolor[1] = RGB_TO_U(r,g,b,0);
2481
    padcolor[2] = RGB_TO_V(r,g,b,0);
2482
}
2483

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

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

    
2510

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

    
2524

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

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

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

    
2562
static void opt_frame_aspect_ratio(const char *arg)
2563
{
2564
    int x = 0, y = 0;
2565
    double ar = 0;
2566
    const char *p;
2567
    char *end;
2568

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

    
2579
    if (!ar) {
2580
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2581
        av_exit(1);
2582
    }
2583
    frame_aspect_ratio = ar;
2584
}
2585

    
2586
static int opt_metadata(const char *opt, const char *arg)
2587
{
2588
    char *mid= strchr(arg, '=');
2589

    
2590
    if(!mid){
2591
        fprintf(stderr, "Missing =\n");
2592
        av_exit(1);
2593
    }
2594
    *mid++= 0;
2595

    
2596
    metadata_count++;
2597
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2598
    metadata[metadata_count-1].key  = av_strdup(arg);
2599
    metadata[metadata_count-1].value= av_strdup(mid);
2600

    
2601
    return 0;
2602
}
2603

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

    
2614
static void opt_top_field_first(const char *arg)
2615
{
2616
    top_field_first= atoi(arg);
2617
}
2618

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

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

    
2639
static int opt_audio_rate(const char *opt, const char *arg)
2640
{
2641
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2642
    return 0;
2643
}
2644

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

    
2651
static void opt_video_channel(const char *arg)
2652
{
2653
    video_channel = strtol(arg, NULL, 0);
2654
}
2655

    
2656
static void opt_video_standard(const char *arg)
2657
{
2658
    video_standard = av_strdup(arg);
2659
}
2660

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

    
2672
static void opt_audio_codec(const char *arg)
2673
{
2674
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2675
}
2676

    
2677
static void opt_audio_tag(const char *arg)
2678
{
2679
    char *tail;
2680
    audio_codec_tag= strtol(arg, &tail, 0);
2681

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

    
2686
static void opt_video_tag(const char *arg)
2687
{
2688
    char *tail;
2689
    video_codec_tag= strtol(arg, &tail, 0);
2690

    
2691
    if(!tail || *tail)
2692
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2693
}
2694

    
2695
static void opt_video_codec(const char *arg)
2696
{
2697
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2698
}
2699

    
2700
static void opt_subtitle_codec(const char *arg)
2701
{
2702
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2703
}
2704

    
2705
static void opt_subtitle_tag(const char *arg)
2706
{
2707
    char *tail;
2708
    subtitle_codec_tag= strtol(arg, &tail, 0);
2709

    
2710
    if(!tail || *tail)
2711
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2712
}
2713

    
2714
static void opt_map(const char *arg)
2715
{
2716
    AVStreamMap *m;
2717
    char *p;
2718

    
2719
    m = &stream_maps[nb_stream_maps++];
2720

    
2721
    m->file_index = strtol(arg, &p, 0);
2722
    if (*p)
2723
        p++;
2724

    
2725
    m->stream_index = strtol(p, &p, 0);
2726
    if (*p) {
2727
        p++;
2728
        m->sync_file_index = strtol(p, &p, 0);
2729
        if (*p)
2730
            p++;
2731
        m->sync_stream_index = strtol(p, &p, 0);
2732
    } else {
2733
        m->sync_file_index = m->file_index;
2734
        m->sync_stream_index = m->stream_index;
2735
    }
2736
}
2737

    
2738
static void opt_map_meta_data(const char *arg)
2739
{
2740
    AVMetaDataMap *m;
2741
    char *p;
2742

    
2743
    m = &meta_data_maps[nb_meta_data_maps++];
2744

    
2745
    m->out_file = strtol(arg, &p, 0);
2746
    if (*p)
2747
        p++;
2748

    
2749
    m->in_file = strtol(p, &p, 0);
2750
}
2751

    
2752
static void opt_input_ts_scale(const char *arg)
2753
{
2754
    unsigned int stream;
2755
    double scale;
2756
    char *p;
2757

    
2758
    stream = strtol(arg, &p, 0);
2759
    if (*p)
2760
        p++;
2761
    scale= strtod(p, &p);
2762

    
2763
    if(stream >= MAX_STREAMS)
2764
        av_exit(1);
2765

    
2766
    input_files_ts_scale[nb_input_files][stream]= scale;
2767
}
2768

    
2769
static int opt_recording_time(const char *opt, const char *arg)
2770
{
2771
    recording_time = parse_time_or_die(opt, arg, 1);
2772
    return 0;
2773
}
2774

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

    
2781
static int opt_rec_timestamp(const char *opt, const char *arg)
2782
{
2783
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2784
    return 0;
2785
}
2786

    
2787
static int opt_input_ts_offset(const char *opt, const char *arg)
2788
{
2789
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2790
    return 0;
2791
}
2792

    
2793
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2794
{
2795
    const char *codec_string = encoder ? "encoder" : "decoder";
2796
    AVCodec *codec;
2797

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

    
2814
static void opt_input_file(const char *filename)
2815
{
2816
    AVFormatContext *ic;
2817
    AVFormatParameters params, *ap = &params;
2818
    int err, i, ret, rfps, rfps_base;
2819
    int64_t timestamp;
2820

    
2821
    if (!strcmp(filename, "-"))
2822
        filename = "pipe:";
2823

    
2824
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2825
                    !strcmp(filename, "/dev/stdin");
2826

    
2827
    /* get default parameters from command line */
2828
    ic = avformat_alloc_context();
2829

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

    
2847
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2848

    
2849
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2850
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2851
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2852
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2853

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

    
2867
    ic->loop_input = loop_input;
2868

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

    
2877
    timestamp = start_time;
2878
    /* add the stream start time */
2879
    if (ic->start_time != AV_NOPTS_VALUE)
2880
        timestamp += ic->start_time;
2881

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

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

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

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

    
2933
                    (float)rfps / rfps_base, rfps, rfps_base);
2934
            }
2935
            /* update the current frame rate to match the stream frame rate */
2936
            frame_rate.num = rfps;
2937
            frame_rate.den = rfps_base;
2938

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

    
2961
    input_files[nb_input_files] = ic;
2962
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2963
    /* dump the file content */
2964
    if (verbose >= 0)
2965
        dump_format(ic, nb_input_files, filename, 0);
2966

    
2967
    nb_input_files++;
2968
    file_iformat = NULL;
2969
    file_oformat = NULL;
2970

    
2971
    video_channel = 0;
2972

    
2973
    av_freep(&video_codec_name);
2974
    av_freep(&audio_codec_name);
2975
    av_freep(&subtitle_codec_name);
2976
}
2977

    
2978
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2979
                                         int *has_subtitle_ptr)
2980
{
2981
    int has_video, has_audio, has_subtitle, i, j;
2982
    AVFormatContext *ic;
2983

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

    
3015
static void new_video_stream(AVFormatContext *oc)
3016
{
3017
    AVStream *st;
3018
    AVCodecContext *video_enc;
3019
    int codec_id;
3020

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

    
3030
    if(thread_count>1)
3031
        avcodec_thread_init(st->codec, thread_count);
3032

    
3033
    video_enc = st->codec;
3034

    
3035
    if(video_codec_tag)
3036
        video_enc->codec_tag= video_codec_tag;
3037

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

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

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

    
3068
        video_enc->codec_id = codec_id;
3069

    
3070
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3071

    
3072
        if (codec && codec->supported_framerates && !force_fps)
3073
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3074
        video_enc->time_base.den = fps.num;
3075
        video_enc->time_base.num = fps.den;
3076

    
3077
        video_enc->width = frame_width + frame_padright + frame_padleft;
3078
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3079
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3080
        video_enc->pix_fmt = frame_pix_fmt;
3081
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3082

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

    
3093
        if (intra_only)
3094
            video_enc->gop_size = 0;
3095
        if (video_qscale || same_quality) {
3096
            video_enc->flags |= CODEC_FLAG_QSCALE;
3097
            video_enc->global_quality=
3098
                st->quality = FF_QP2LAMBDA * video_qscale;
3099
        }
3100

    
3101
        if(intra_matrix)
3102
            video_enc->intra_matrix = intra_matrix;
3103
        if(inter_matrix)
3104
            video_enc->inter_matrix = inter_matrix;
3105

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

    
3137
        if (do_psnr)
3138
            video_enc->flags|= CODEC_FLAG_PSNR;
3139

    
3140
        /* two pass mode */
3141
        if (do_pass) {
3142
            if (do_pass == 1) {
3143
                video_enc->flags |= CODEC_FLAG_PASS1;
3144
            } else {
3145
                video_enc->flags |= CODEC_FLAG_PASS2;
3146
            }
3147
        }
3148
    }
3149
    nb_ocodecs++;
3150

    
3151
    /* reset some key parameters */
3152
    video_disable = 0;
3153
    av_freep(&video_codec_name);
3154
    video_stream_copy = 0;
3155
}
3156

    
3157
static void new_audio_stream(AVFormatContext *oc)
3158
{
3159
    AVStream *st;
3160
    AVCodecContext *audio_enc;
3161
    int codec_id;
3162

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

    
3170
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3171
    audio_bitstream_filters= NULL;
3172

    
3173
    if(thread_count>1)
3174
        avcodec_thread_init(st->codec, thread_count);
3175

    
3176
    audio_enc = st->codec;
3177
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3178

    
3179
    if(audio_codec_tag)
3180
        audio_enc->codec_tag= audio_codec_tag;
3181

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

    
3192
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3193

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

    
3204
        if (audio_qscale > QSCALE_NONE) {
3205
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3206
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3207
        }
3208
        audio_enc->thread_count = thread_count;
3209
        audio_enc->channels = audio_channels;
3210
        audio_enc->sample_fmt = audio_sample_fmt;
3211
        audio_enc->channel_layout = channel_layout;
3212
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3213
            audio_enc->channel_layout = 0;
3214

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

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

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

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

    
3252
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3253
    subtitle_bitstream_filters= NULL;
3254

    
3255
    subtitle_enc = st->codec;
3256
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3257

    
3258
    if(subtitle_codec_tag)
3259
        subtitle_enc->codec_tag= subtitle_codec_tag;
3260

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

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

    
3276
    subtitle_disable = 0;
3277
    av_freep(&subtitle_codec_name);
3278
    subtitle_stream_copy = 0;
3279
}
3280

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

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

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

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

    
3321
    if (!strcmp(filename, "-"))
3322
        filename = "pipe:";
3323

    
3324
    oc = avformat_alloc_context();
3325

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

    
3335
    oc->oformat = file_oformat;
3336
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3337

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

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

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

    
3376
        if (use_video) {
3377
            new_video_stream(oc);
3378
        }
3379

    
3380
        if (use_audio) {
3381
            new_audio_stream(oc);
3382
        }
3383

    
3384
        if (use_subtitle) {
3385
            new_subtitle_stream(oc);
3386
        }
3387

    
3388
        oc->timestamp = rec_timestamp;
3389

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

    
3397
    output_files[nb_output_files++] = oc;
3398

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

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

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

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

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

    
3448
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3449

    
3450
    /* reset some options */
3451
    file_oformat = NULL;
3452
    file_iformat = NULL;
3453
}
3454

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

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

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

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

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

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

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

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

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

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

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

    
3616
    if(!strcmp(arg, "vcd")) {
3617

    
3618
        opt_video_codec("mpeg1video");
3619
        opt_audio_codec("mp2");
3620
        opt_format("vcd");
3621

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

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

    
3631
        opt_default("ab", "224000");
3632
        audio_sample_rate = 44100;
3633
        audio_channels = 2;
3634

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

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

    
3646
        opt_video_codec("mpeg2video");
3647
        opt_audio_codec("mp2");
3648
        opt_format("svcd");
3649

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

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

    
3660

    
3661
        opt_default("ab", "224000");
3662
        audio_sample_rate = 44100;
3663

    
3664
        opt_default("packetsize", "2324");
3665

    
3666
    } else if(!strcmp(arg, "dvd")) {
3667

    
3668
        opt_video_codec("mpeg2video");
3669
        opt_audio_codec("ac3");
3670
        opt_format("dvd");
3671

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

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

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

    
3684
        opt_default("ab", "448000");
3685
        audio_sample_rate = 48000;
3686

    
3687
    } else if(!strncmp(arg, "dv", 2)) {
3688

    
3689
        opt_format("dv");
3690

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

    
3696
        audio_sample_rate = 48000;
3697
        audio_channels = 2;
3698

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

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

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

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

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

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

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

    
3738
    *bsfp= bsfc;
3739

    
3740
    return 0;
3741
}
3742

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

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

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

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

    
3795
    fclose(f);
3796

    
3797
    return 0;
3798
}
3799

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

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

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

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

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

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

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

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

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

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

    
3932
    avcodec_register_all();
3933
    avdevice_register_all();
3934
    av_register_all();
3935

    
3936
    if(isatty(STDIN_FILENO))
3937
        url_set_interrupt_cb(decode_interrupt_cb);
3938

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

    
3945
    show_banner();
3946

    
3947
    /* parse options */
3948
    parse_options(argc, argv, options, opt_output_file);
3949

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

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

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

    
3970
    return av_exit(0);
3971
}