Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ cedac882

History | View | Annotate | Download (146 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/pixdesc.h"
42
#include "libavutil/avstring.h"
43
#include "libavformat/os_support.h"
44

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

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

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

    
67
#include "cmdutils.h"
68

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

    
72
#undef exit
73

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

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

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

    
91
static const OptionDef options[];
92

    
93
#define MAX_FILES 100
94

    
95
static const char *last_asked_format = NULL;
96
static AVFormatContext *input_files[MAX_FILES];
97
static int64_t input_files_ts_offset[MAX_FILES];
98
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
99
static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
100
static int nb_input_files = 0;
101
static int nb_icodecs;
102

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

    
108
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
109
static int nb_stream_maps;
110

    
111
static AVMetaDataMap meta_data_maps[MAX_FILES];
112
static int nb_meta_data_maps;
113

    
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
static const char *video_rc_override_string=NULL;
134
static int video_disable = 0;
135
static int video_discard = 0;
136
static char *video_codec_name = NULL;
137
static int video_codec_tag = 0;
138
static char *video_language = NULL;
139
static int same_quality = 0;
140
static int do_deinterlace = 0;
141
static int top_field_first = -1;
142
static int me_threshold = 0;
143
static int intra_dc_precision = 8;
144
static int loop_input = 0;
145
static int loop_output = AVFMT_NOOUTPUTLOOP;
146
static int qp_hist = 0;
147

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

    
159
static int subtitle_disable = 0;
160
static char *subtitle_codec_name = NULL;
161
static char *subtitle_language = NULL;
162
static int subtitle_codec_tag = 0;
163

    
164
static float mux_preload= 0.5;
165
static float mux_max_delay= 0.7;
166

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

    
194
static int rate_emu = 0;
195

    
196
static int  video_channel = 0;
197
static char *video_standard;
198

    
199
static int audio_volume = 256;
200

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

    
215
static int pgmyuv_compatibility_hack=0;
216
static float dts_delta_threshold = 10;
217

    
218
static unsigned int sws_flags = SWS_BICUBIC;
219

    
220
static int64_t timer_start;
221

    
222
static uint8_t *audio_buf;
223
static uint8_t *audio_out;
224
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
225

    
226
static short *samples;
227

    
228
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
229
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
230
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
231
static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
232

    
233
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
234

    
235
struct AVInputStream;
236

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

    
257
    /* full frame size of first frame */
258
    int original_height;
259
    int original_width;
260

    
261
    /* cropping area sizes */
262
    int video_crop;
263
    int topBand;
264
    int bottomBand;
265
    int leftBand;
266
    int rightBand;
267

    
268
    /* cropping area of first frame */
269
    int original_topBand;
270
    int original_bottomBand;
271
    int original_leftBand;
272
    int original_rightBand;
273

    
274
    /* padding area sizes */
275
    int video_pad;
276
    int padtop;
277
    int padbottom;
278
    int padleft;
279
    int padright;
280

    
281
    /* audio only */
282
    int audio_resample;
283
    ReSampleContext *resample; /* for audio resampling */
284
    int reformat_pair;
285
    AVAudioConvert *reformat_ctx;
286
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
287
    FILE *logfile;
288
} AVOutputStream;
289

    
290
typedef struct AVInputStream {
291
    int file_index;
292
    int index;
293
    AVStream *st;
294
    int discard;             /* true if stream data should be discarded */
295
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
296
    int64_t sample_index;      /* current sample */
297

    
298
    int64_t       start;     /* time when read started */
299
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
300
                                is not defined */
301
    int64_t       pts;       /* current pts */
302
    int is_start;            /* is 1 at the start and after a discontinuity */
303
    int showed_multi_packet_warning;
304
} AVInputStream;
305

    
306
typedef struct AVInputFile {
307
    int eof_reached;      /* true if eof reached */
308
    int ist_index;        /* index of first stream in ist_table */
309
    int buffer_size;      /* current total buffer size */
310
    int nb_streams;       /* nb streams we are aware of */
311
} AVInputFile;
312

    
313
#if HAVE_TERMIOS_H
314

    
315
/* init terminal so that we can grab keys */
316
static struct termios oldtty;
317
#endif
318

    
319
static void term_exit(void)
320
{
321
#if HAVE_TERMIOS_H
322
    tcsetattr (0, TCSANOW, &oldtty);
323
#endif
324
}
325

    
326
static volatile int received_sigterm = 0;
327

    
328
static void
329
sigterm_handler(int sig)
330
{
331
    received_sigterm = sig;
332
    term_exit();
333
}
334

    
335
static void term_init(void)
336
{
337
#if HAVE_TERMIOS_H
338
    struct termios tty;
339

    
340
    tcgetattr (0, &tty);
341
    oldtty = tty;
342

    
343
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
344
                          |INLCR|IGNCR|ICRNL|IXON);
345
    tty.c_oflag |= OPOST;
346
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
347
    tty.c_cflag &= ~(CSIZE|PARENB);
348
    tty.c_cflag |= CS8;
349
    tty.c_cc[VMIN] = 1;
350
    tty.c_cc[VTIME] = 0;
351

    
352
    tcsetattr (0, TCSANOW, &tty);
353
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
354
#endif
355

    
356
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
357
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
358
#ifdef SIGXCPU
359
    signal(SIGXCPU, sigterm_handler);
360
#endif
361

    
362
    /*
363
    register a function to be called at normal program termination
364
    */
365
    atexit(term_exit);
366
#if CONFIG_BEOS_NETSERVER
367
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
368
#endif
369
}
370

    
371
/* read a key without blocking */
372
static int read_key(void)
373
{
374
#if HAVE_TERMIOS_H
375
    int n = 1;
376
    unsigned char ch;
377
#if !CONFIG_BEOS_NETSERVER
378
    struct timeval tv;
379
    fd_set rfds;
380

    
381
    FD_ZERO(&rfds);
382
    FD_SET(0, &rfds);
383
    tv.tv_sec = 0;
384
    tv.tv_usec = 0;
385
    n = select(1, &rfds, NULL, NULL, &tv);
386
#endif
387
    if (n > 0) {
388
        n = read(0, &ch, 1);
389
        if (n == 1)
390
            return ch;
391

    
392
        return n;
393
    }
394
#elif HAVE_CONIO_H
395
    if(kbhit())
396
        return(getch());
397
#endif
398
    return -1;
399
}
400

    
401
static int decode_interrupt_cb(void)
402
{
403
    return q_pressed || (q_pressed = read_key() == 'q');
404
}
405

    
406
static int av_exit(int ret)
407
{
408
    int i;
409

    
410
    /* close files */
411
    for(i=0;i<nb_output_files;i++) {
412
        /* maybe av_close_output_file ??? */
413
        AVFormatContext *s = output_files[i];
414
        int j;
415
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
416
            url_fclose(s->pb);
417
        for(j=0;j<s->nb_streams;j++) {
418
            av_metadata_free(&s->streams[j]->metadata);
419
            av_free(s->streams[j]->codec);
420
            av_free(s->streams[j]);
421
        }
422
        for(j=0;j<s->nb_programs;j++) {
423
            av_metadata_free(&s->programs[j]->metadata);
424
        }
425
        for(j=0;j<s->nb_chapters;j++) {
426
            av_metadata_free(&s->chapters[j]->metadata);
427
        }
428
        av_metadata_free(&s->metadata);
429
        av_free(s);
430
    }
431
    for(i=0;i<nb_input_files;i++)
432
        av_close_input_file(input_files[i]);
433

    
434
    av_free(intra_matrix);
435
    av_free(inter_matrix);
436

    
437
    if (vstats_file)
438
        fclose(vstats_file);
439
    av_free(vstats_filename);
440

    
441
    av_free(opt_names);
442

    
443
    av_free(video_codec_name);
444
    av_free(audio_codec_name);
445
    av_free(subtitle_codec_name);
446

    
447
    av_free(video_standard);
448

    
449
#if CONFIG_POWERPC_PERF
450
    void powerpc_display_perf_report(void);
451
    powerpc_display_perf_report();
452
#endif /* CONFIG_POWERPC_PERF */
453

    
454
    for (i=0;i<CODEC_TYPE_NB;i++)
455
        av_free(avcodec_opts[i]);
456
    av_free(avformat_opts);
457
    av_free(sws_opts);
458
    av_free(audio_buf);
459
    av_free(audio_out);
460
    allocated_audio_buf_size= allocated_audio_out_size= 0;
461
    av_free(samples);
462

    
463
    if (received_sigterm) {
464
        fprintf(stderr,
465
            "Received signal %d: terminating.\n",
466
            (int) received_sigterm);
467
        exit (255);
468
    }
469

    
470
    exit(ret); /* not all OS-es handle main() return value */
471
    return ret;
472
}
473

    
474
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
475
{
476
    int i, err;
477
    AVFormatContext *ic;
478
    int nopts = 0;
479

    
480
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
481
    if (err < 0)
482
        return err;
483
    /* copy stream format */
484
    s->nb_streams = ic->nb_streams;
485
    for(i=0;i<ic->nb_streams;i++) {
486
        AVStream *st;
487

    
488
        // FIXME: a more elegant solution is needed
489
        st = av_mallocz(sizeof(AVStream));
490
        memcpy(st, ic->streams[i], sizeof(AVStream));
491
        st->codec = avcodec_alloc_context();
492
        if (!st->codec) {
493
            print_error(filename, AVERROR(ENOMEM));
494
            av_exit(1);
495
        }
496
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
497
        s->streams[i] = st;
498

    
499
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
500
            st->stream_copy = 1;
501
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
502
            st->stream_copy = 1;
503

    
504
        if(!st->codec->thread_count)
505
            st->codec->thread_count = 1;
506
        if(st->codec->thread_count>1)
507
            avcodec_thread_init(st->codec, st->codec->thread_count);
508

    
509
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
510
            nopts = 1;
511
    }
512

    
513
    if (!nopts)
514
        s->timestamp = av_gettime();
515

    
516
    av_close_input_file(ic);
517
    return 0;
518
}
519

    
520
static double
521
get_sync_ipts(const AVOutputStream *ost)
522
{
523
    const AVInputStream *ist = ost->sync_ist;
524
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
525
}
526

    
527
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
528
    int ret;
529

    
530
    while(bsfc){
531
        AVPacket new_pkt= *pkt;
532
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
533
                                          &new_pkt.data, &new_pkt.size,
534
                                          pkt->data, pkt->size,
535
                                          pkt->flags & PKT_FLAG_KEY);
536
        if(a>0){
537
            av_free_packet(pkt);
538
            new_pkt.destruct= av_destruct_packet;
539
        } else if(a<0){
540
            fprintf(stderr, "%s failed for stream %d, codec %s",
541
                    bsfc->filter->name, pkt->stream_index,
542
                    avctx->codec ? avctx->codec->name : "copy");
543
            print_error("", a);
544
            if (exit_on_error)
545
                av_exit(1);
546
        }
547
        *pkt= new_pkt;
548

    
549
        bsfc= bsfc->next;
550
    }
551

    
552
    ret= av_interleaved_write_frame(s, pkt);
553
    if(ret < 0){
554
        print_error("av_interleaved_write_frame()", ret);
555
        av_exit(1);
556
    }
557
}
558

    
559
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
560

    
561
static void do_audio_out(AVFormatContext *s,
562
                         AVOutputStream *ost,
563
                         AVInputStream *ist,
564
                         unsigned char *buf, int size)
565
{
566
    uint8_t *buftmp;
567
    int64_t audio_out_size, audio_buf_size;
568
    int64_t allocated_for_size= size;
569

    
570
    int size_out, frame_bytes, ret;
571
    AVCodecContext *enc= ost->st->codec;
572
    AVCodecContext *dec= ist->st->codec;
573
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
574
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
575
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
576

    
577
need_realloc:
578
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
579
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
580
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
581
    audio_buf_size*= osize*enc->channels;
582

    
583
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
584
    if(coded_bps > 8*osize)
585
        audio_out_size= audio_out_size * coded_bps / (8*osize);
586
    audio_out_size += FF_MIN_BUFFER_SIZE;
587

    
588
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
589
        fprintf(stderr, "Buffer sizes too large\n");
590
        av_exit(1);
591
    }
592

    
593
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
594
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
595
    if (!audio_buf || !audio_out){
596
        fprintf(stderr, "Out of memory in do_audio_out\n");
597
        av_exit(1);
598
    }
599

    
600
    if (enc->channels != dec->channels)
601
        ost->audio_resample = 1;
602

    
603
    if (ost->audio_resample && !ost->resample) {
604
        if (dec->sample_fmt != SAMPLE_FMT_S16)
605
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
606
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
607
                                               enc->sample_rate, dec->sample_rate,
608
                                               enc->sample_fmt,  dec->sample_fmt,
609
                                               16, 10, 0, 0.8);
610
        if (!ost->resample) {
611
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
612
                    dec->channels, dec->sample_rate,
613
                    enc->channels, enc->sample_rate);
614
            av_exit(1);
615
        }
616
    }
617

    
618
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
619
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
620
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
621
        if (ost->reformat_ctx)
622
            av_audio_convert_free(ost->reformat_ctx);
623
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
624
                                                   dec->sample_fmt, 1, NULL, 0);
625
        if (!ost->reformat_ctx) {
626
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
627
                avcodec_get_sample_fmt_name(dec->sample_fmt),
628
                avcodec_get_sample_fmt_name(enc->sample_fmt));
629
            av_exit(1);
630
        }
631
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
632
    }
633

    
634
    if(audio_sync_method){
635
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
636
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
637
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
638
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
639

    
640
        //FIXME resample delay
641
        if(fabs(delta) > 50){
642
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
643
                if(byte_delta < 0){
644
                    byte_delta= FFMAX(byte_delta, -size);
645
                    size += byte_delta;
646
                    buf  -= byte_delta;
647
                    if(verbose > 2)
648
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
649
                    if(!size)
650
                        return;
651
                    ist->is_start=0;
652
                }else{
653
                    static uint8_t *input_tmp= NULL;
654
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
655

    
656
                    if(byte_delta > allocated_for_size - size){
657
                        allocated_for_size= byte_delta + (int64_t)size;
658
                        goto need_realloc;
659
                    }
660
                    ist->is_start=0;
661

    
662
                    memset(input_tmp, 0, byte_delta);
663
                    memcpy(input_tmp + byte_delta, buf, size);
664
                    buf= input_tmp;
665
                    size += byte_delta;
666
                    if(verbose > 2)
667
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
668
                }
669
            }else if(audio_sync_method>1){
670
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
671
                assert(ost->audio_resample);
672
                if(verbose > 2)
673
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
674
//                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));
675
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
676
            }
677
        }
678
    }else
679
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
680
                        - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
681

    
682
    if (ost->audio_resample) {
683
        buftmp = audio_buf;
684
        size_out = audio_resample(ost->resample,
685
                                  (short *)buftmp, (short *)buf,
686
                                  size / (ist->st->codec->channels * isize));
687
        size_out = size_out * enc->channels * osize;
688
    } else {
689
        buftmp = buf;
690
        size_out = size;
691
    }
692

    
693
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
694
        const void *ibuf[6]= {buftmp};
695
        void *obuf[6]= {audio_buf};
696
        int istride[6]= {isize};
697
        int ostride[6]= {osize};
698
        int len= size_out/istride[0];
699
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
700
            printf("av_audio_convert() failed\n");
701
            if (exit_on_error)
702
                av_exit(1);
703
            return;
704
        }
705
        buftmp = audio_buf;
706
        size_out = len*osize;
707
    }
708

    
709
    /* now encode as many frames as possible */
710
    if (enc->frame_size > 1) {
711
        /* output resampled raw samples */
712
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
713
            fprintf(stderr, "av_fifo_realloc2() failed\n");
714
            av_exit(1);
715
        }
716
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
717

    
718
        frame_bytes = enc->frame_size * osize * enc->channels;
719

    
720
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
721
            AVPacket pkt;
722
            av_init_packet(&pkt);
723

    
724
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
725

    
726
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
727

    
728
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
729
                                       (short *)audio_buf);
730
            if (ret < 0) {
731
                fprintf(stderr, "Audio encoding failed\n");
732
                av_exit(1);
733
            }
734
            audio_size += ret;
735
            pkt.stream_index= ost->index;
736
            pkt.data= audio_out;
737
            pkt.size= ret;
738
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
739
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
740
            pkt.flags |= PKT_FLAG_KEY;
741
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
742

    
743
            ost->sync_opts += enc->frame_size;
744
        }
745
    } else {
746
        AVPacket pkt;
747
        av_init_packet(&pkt);
748

    
749
        ost->sync_opts += size_out / (osize * enc->channels);
750

    
751
        /* output a pcm frame */
752
        /* determine the size of the coded buffer */
753
        size_out /= osize;
754
        if (coded_bps)
755
            size_out = size_out*coded_bps/8;
756

    
757
        if(size_out > audio_out_size){
758
            fprintf(stderr, "Internal error, buffer size too small\n");
759
            av_exit(1);
760
        }
761

    
762
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
763
        ret = avcodec_encode_audio(enc, audio_out, size_out,
764
                                   (short *)buftmp);
765
        if (ret < 0) {
766
            fprintf(stderr, "Audio encoding failed\n");
767
            av_exit(1);
768
        }
769
        audio_size += ret;
770
        pkt.stream_index= ost->index;
771
        pkt.data= audio_out;
772
        pkt.size= ret;
773
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
774
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
775
        pkt.flags |= PKT_FLAG_KEY;
776
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
777
    }
778
}
779

    
780
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
781
{
782
    AVCodecContext *dec;
783
    AVPicture *picture2;
784
    AVPicture picture_tmp;
785
    uint8_t *buf = 0;
786

    
787
    dec = ist->st->codec;
788

    
789
    /* deinterlace : must be done before any resize */
790
    if (do_deinterlace) {
791
        int size;
792

    
793
        /* create temporary picture */
794
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
795
        buf = av_malloc(size);
796
        if (!buf)
797
            return;
798

    
799
        picture2 = &picture_tmp;
800
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
801

    
802
        if(avpicture_deinterlace(picture2, picture,
803
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
804
            /* if error, do not deinterlace */
805
            fprintf(stderr, "Deinterlacing failed\n");
806
            av_free(buf);
807
            buf = NULL;
808
            picture2 = picture;
809
        }
810
    } else {
811
        picture2 = picture;
812
    }
813

    
814
    if (picture != picture2)
815
        *picture = *picture2;
816
    *bufp = buf;
817
}
818

    
819
/* we begin to correct av delay at this threshold */
820
#define AV_DELAY_MAX 0.100
821

    
822
static void do_subtitle_out(AVFormatContext *s,
823
                            AVOutputStream *ost,
824
                            AVInputStream *ist,
825
                            AVSubtitle *sub,
826
                            int64_t pts)
827
{
828
    static uint8_t *subtitle_out = NULL;
829
    int subtitle_out_max_size = 1024 * 1024;
830
    int subtitle_out_size, nb, i;
831
    AVCodecContext *enc;
832
    AVPacket pkt;
833

    
834
    if (pts == AV_NOPTS_VALUE) {
835
        fprintf(stderr, "Subtitle packets must have a pts\n");
836
        if (exit_on_error)
837
            av_exit(1);
838
        return;
839
    }
840

    
841
    enc = ost->st->codec;
842

    
843
    if (!subtitle_out) {
844
        subtitle_out = av_malloc(subtitle_out_max_size);
845
    }
846

    
847
    /* Note: DVB subtitle need one packet to draw them and one other
848
       packet to clear them */
849
    /* XXX: signal it in the codec context ? */
850
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
851
        nb = 2;
852
    else
853
        nb = 1;
854

    
855
    for(i = 0; i < nb; i++) {
856
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
857
        // start_display_time is required to be 0
858
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
859
        sub->end_display_time -= sub->start_display_time;
860
        sub->start_display_time = 0;
861
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
862
                                                    subtitle_out_max_size, sub);
863
        if (subtitle_out_size < 0) {
864
            fprintf(stderr, "Subtitle encoding failed\n");
865
            av_exit(1);
866
        }
867

    
868
        av_init_packet(&pkt);
869
        pkt.stream_index = ost->index;
870
        pkt.data = subtitle_out;
871
        pkt.size = subtitle_out_size;
872
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
873
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
874
            /* XXX: the pts correction is handled here. Maybe handling
875
               it in the codec would be better */
876
            if (i == 0)
877
                pkt.pts += 90 * sub->start_display_time;
878
            else
879
                pkt.pts += 90 * sub->end_display_time;
880
        }
881
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
882
    }
883
}
884

    
885
static int bit_buffer_size= 1024*256;
886
static uint8_t *bit_buffer= NULL;
887

    
888
static void do_video_out(AVFormatContext *s,
889
                         AVOutputStream *ost,
890
                         AVInputStream *ist,
891
                         AVFrame *in_picture,
892
                         int *frame_size)
893
{
894
    int nb_frames, i, ret;
895
    int64_t topBand, bottomBand, leftBand, rightBand;
896
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
897
    AVFrame picture_crop_temp, picture_pad_temp;
898
    AVCodecContext *enc, *dec;
899

    
900
    avcodec_get_frame_defaults(&picture_crop_temp);
901
    avcodec_get_frame_defaults(&picture_pad_temp);
902

    
903
    enc = ost->st->codec;
904
    dec = ist->st->codec;
905

    
906
    /* by default, we output a single frame */
907
    nb_frames = 1;
908

    
909
    *frame_size = 0;
910

    
911
    if(video_sync_method){
912
        double vdelta;
913
        vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
914
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
915
        if (vdelta < -1.1)
916
            nb_frames = 0;
917
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
918
            if(vdelta<=-0.6){
919
                nb_frames=0;
920
            }else if(vdelta>0.6)
921
            ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
922
        }else if (vdelta > 1.1)
923
            nb_frames = lrintf(vdelta);
924
//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);
925
        if (nb_frames == 0){
926
            ++nb_frames_drop;
927
            if (verbose>2)
928
                fprintf(stderr, "*** drop!\n");
929
        }else if (nb_frames > 1) {
930
            nb_frames_dup += nb_frames - 1;
931
            if (verbose>2)
932
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
933
        }
934
    }else
935
        ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
936

    
937
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
938
    if (nb_frames <= 0)
939
        return;
940

    
941
    if (ost->video_crop) {
942
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
943
            fprintf(stderr, "error cropping picture\n");
944
            if (exit_on_error)
945
                av_exit(1);
946
            return;
947
        }
948
        formatted_picture = &picture_crop_temp;
949
    } else {
950
        formatted_picture = in_picture;
951
    }
952

    
953
    final_picture = formatted_picture;
954
    padding_src = formatted_picture;
955
    resampling_dst = &ost->pict_tmp;
956
    if (ost->video_pad) {
957
        final_picture = &ost->pict_tmp;
958
        if (ost->video_resample) {
959
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
960
                fprintf(stderr, "error padding picture\n");
961
                if (exit_on_error)
962
                    av_exit(1);
963
                return;
964
            }
965
            resampling_dst = &picture_pad_temp;
966
        }
967
    }
968

    
969
    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
970
        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
971
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
972

    
973
        fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width,     ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
974
        if(!ost->video_resample)
975
            av_exit(1);
976
    }
977

    
978
    if (ost->video_resample) {
979
        padding_src = NULL;
980
        final_picture = &ost->pict_tmp;
981
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
982
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
983
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
984

    
985
            /* keep bands proportional to the frame size */
986
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
987
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
988
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
989
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
990

    
991
            /* sanity check to ensure no bad band sizes sneak in */
992
            assert(topBand    <= INT_MAX && topBand    >= 0);
993
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
994
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
995
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
996

    
997
            ost->topBand    = topBand;
998
            ost->bottomBand = bottomBand;
999
            ost->leftBand   = leftBand;
1000
            ost->rightBand  = rightBand;
1001

    
1002
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
1003
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
1004
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1005

    
1006
            /* initialize a new scaler context */
1007
            sws_freeContext(ost->img_resample_ctx);
1008
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1009
            ost->img_resample_ctx = sws_getContext(
1010
                ist->st->codec->width  - (ost->leftBand + ost->rightBand),
1011
                ist->st->codec->height - (ost->topBand  + ost->bottomBand),
1012
                ist->st->codec->pix_fmt,
1013
                ost->st->codec->width  - (ost->padleft  + ost->padright),
1014
                ost->st->codec->height - (ost->padtop   + ost->padbottom),
1015
                ost->st->codec->pix_fmt,
1016
                sws_flags, NULL, NULL, NULL);
1017
            if (ost->img_resample_ctx == NULL) {
1018
                fprintf(stderr, "Cannot get resampling context\n");
1019
                av_exit(1);
1020
            }
1021
        }
1022
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1023
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1024
    }
1025

    
1026
    if (ost->video_pad) {
1027
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1028
                enc->height, enc->width, enc->pix_fmt,
1029
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1030
    }
1031

    
1032
    /* duplicates frame if needed */
1033
    for(i=0;i<nb_frames;i++) {
1034
        AVPacket pkt;
1035
        av_init_packet(&pkt);
1036
        pkt.stream_index= ost->index;
1037

    
1038
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1039
            /* raw pictures are written as AVPicture structure to
1040
               avoid any copies. We support temorarily the older
1041
               method. */
1042
            AVFrame* old_frame = enc->coded_frame;
1043
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1044
            pkt.data= (uint8_t *)final_picture;
1045
            pkt.size=  sizeof(AVPicture);
1046
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1047
            pkt.flags |= PKT_FLAG_KEY;
1048

    
1049
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1050
            enc->coded_frame = old_frame;
1051
        } else {
1052
            AVFrame big_picture;
1053

    
1054
            big_picture= *final_picture;
1055
            /* better than nothing: use input picture interlaced
1056
               settings */
1057
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1058
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1059
                if(top_field_first == -1)
1060
                    big_picture.top_field_first = in_picture->top_field_first;
1061
                else
1062
                    big_picture.top_field_first = top_field_first;
1063
            }
1064

    
1065
            /* handles sameq here. This is not correct because it may
1066
               not be a global option */
1067
            if (same_quality) {
1068
                big_picture.quality = ist->st->quality;
1069
            }else
1070
                big_picture.quality = ost->st->quality;
1071
            if(!me_threshold)
1072
                big_picture.pict_type = 0;
1073
//            big_picture.pts = AV_NOPTS_VALUE;
1074
            big_picture.pts= ost->sync_opts;
1075
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1076
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1077
            ret = avcodec_encode_video(enc,
1078
                                       bit_buffer, bit_buffer_size,
1079
                                       &big_picture);
1080
            if (ret < 0) {
1081
                fprintf(stderr, "Video encoding failed\n");
1082
                av_exit(1);
1083
            }
1084

    
1085
            if(ret>0){
1086
                pkt.data= bit_buffer;
1087
                pkt.size= ret;
1088
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1089
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1090
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1091
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1092
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1093

    
1094
                if(enc->coded_frame->key_frame)
1095
                    pkt.flags |= PKT_FLAG_KEY;
1096
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1097
                *frame_size = ret;
1098
                video_size += ret;
1099
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1100
                //        enc->frame_number-1, ret, enc->pict_type);
1101
                /* if two pass, output log */
1102
                if (ost->logfile && enc->stats_out) {
1103
                    fprintf(ost->logfile, "%s", enc->stats_out);
1104
                }
1105
            }
1106
        }
1107
        ost->sync_opts++;
1108
        ost->frame_number++;
1109
    }
1110
}
1111

    
1112
static double psnr(double d){
1113
    return -10.0*log(d)/log(10.0);
1114
}
1115

    
1116
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1117
                           int frame_size)
1118
{
1119
    AVCodecContext *enc;
1120
    int frame_number;
1121
    double ti1, bitrate, avg_bitrate;
1122

    
1123
    /* this is executed just the first time do_video_stats is called */
1124
    if (!vstats_file) {
1125
        vstats_file = fopen(vstats_filename, "w");
1126
        if (!vstats_file) {
1127
            perror("fopen");
1128
            av_exit(1);
1129
        }
1130
    }
1131

    
1132
    enc = ost->st->codec;
1133
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1134
        frame_number = ost->frame_number;
1135
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1136
        if (enc->flags&CODEC_FLAG_PSNR)
1137
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1138

    
1139
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1140
        /* compute pts value */
1141
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1142
        if (ti1 < 0.01)
1143
            ti1 = 0.01;
1144

    
1145
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1146
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1147
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1148
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1149
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1150
    }
1151
}
1152

    
1153
static void print_report(AVFormatContext **output_files,
1154
                         AVOutputStream **ost_table, int nb_ostreams,
1155
                         int is_last_report)
1156
{
1157
    char buf[1024];
1158
    AVOutputStream *ost;
1159
    AVFormatContext *oc;
1160
    int64_t total_size;
1161
    AVCodecContext *enc;
1162
    int frame_number, vid, i;
1163
    double bitrate, ti1, pts;
1164
    static int64_t last_time = -1;
1165
    static int qp_histogram[52];
1166

    
1167
    if (!is_last_report) {
1168
        int64_t cur_time;
1169
        /* display the report every 0.5 seconds */
1170
        cur_time = av_gettime();
1171
        if (last_time == -1) {
1172
            last_time = cur_time;
1173
            return;
1174
        }
1175
        if ((cur_time - last_time) < 500000)
1176
            return;
1177
        last_time = cur_time;
1178
    }
1179

    
1180

    
1181
    oc = output_files[0];
1182

    
1183
    total_size = url_fsize(oc->pb);
1184
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1185
        total_size= url_ftell(oc->pb);
1186

    
1187
    buf[0] = '\0';
1188
    ti1 = 1e10;
1189
    vid = 0;
1190
    for(i=0;i<nb_ostreams;i++) {
1191
        ost = ost_table[i];
1192
        enc = ost->st->codec;
1193
        if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1194
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1195
                     !ost->st->stream_copy ?
1196
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1197
        }
1198
        if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1199
            float t = (av_gettime()-timer_start) / 1000000.0;
1200

    
1201
            frame_number = ost->frame_number;
1202
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1203
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1204
                     !ost->st->stream_copy ?
1205
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1206
            if(is_last_report)
1207
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1208
            if(qp_hist){
1209
                int j;
1210
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1211
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1212
                    qp_histogram[qp]++;
1213
                for(j=0; j<32; j++)
1214
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1215
            }
1216
            if (enc->flags&CODEC_FLAG_PSNR){
1217
                int j;
1218
                double error, error_sum=0;
1219
                double scale, scale_sum=0;
1220
                char type[3]= {'Y','U','V'};
1221
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1222
                for(j=0; j<3; j++){
1223
                    if(is_last_report){
1224
                        error= enc->error[j];
1225
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1226
                    }else{
1227
                        error= enc->coded_frame->error[j];
1228
                        scale= enc->width*enc->height*255.0*255.0;
1229
                    }
1230
                    if(j) scale/=4;
1231
                    error_sum += error;
1232
                    scale_sum += scale;
1233
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1234
                }
1235
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1236
            }
1237
            vid = 1;
1238
        }
1239
        /* compute min output value */
1240
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1241
        if ((pts < ti1) && (pts > 0))
1242
            ti1 = pts;
1243
    }
1244
    if (ti1 < 0.01)
1245
        ti1 = 0.01;
1246

    
1247
    if (verbose || is_last_report) {
1248
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1249

    
1250
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1251
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1252
            (double)total_size / 1024, ti1, bitrate);
1253

    
1254
        if (nb_frames_dup || nb_frames_drop)
1255
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1256
                  nb_frames_dup, nb_frames_drop);
1257

    
1258
        if (verbose >= 0)
1259
            fprintf(stderr, "%s    \r", buf);
1260

    
1261
        fflush(stderr);
1262
    }
1263

    
1264
    if (is_last_report && verbose >= 0){
1265
        int64_t raw= audio_size + video_size + extra_size;
1266
        fprintf(stderr, "\n");
1267
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1268
                video_size/1024.0,
1269
                audio_size/1024.0,
1270
                extra_size/1024.0,
1271
                100.0*(total_size - raw)/raw
1272
        );
1273
    }
1274
}
1275

    
1276
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1277
static int output_packet(AVInputStream *ist, int ist_index,
1278
                         AVOutputStream **ost_table, int nb_ostreams,
1279
                         const AVPacket *pkt)
1280
{
1281
    AVFormatContext *os;
1282
    AVOutputStream *ost;
1283
    int ret, i;
1284
    int got_picture;
1285
    AVFrame picture;
1286
    void *buffer_to_free;
1287
    static unsigned int samples_size= 0;
1288
    AVSubtitle subtitle, *subtitle_to_free;
1289
    int got_subtitle;
1290
    AVPacket avpkt;
1291
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1292

    
1293
    if(ist->next_pts == AV_NOPTS_VALUE)
1294
        ist->next_pts= ist->pts;
1295

    
1296
    if (pkt == NULL) {
1297
        /* EOF handling */
1298
        av_init_packet(&avpkt);
1299
        avpkt.data = NULL;
1300
        avpkt.size = 0;
1301
        goto handle_eof;
1302
    } else {
1303
        avpkt = *pkt;
1304
    }
1305

    
1306
    if(pkt->dts != AV_NOPTS_VALUE)
1307
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1308

    
1309
    //while we have more to decode or while the decoder did output something on EOF
1310
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1311
        uint8_t *data_buf, *decoded_data_buf;
1312
        int data_size, decoded_data_size;
1313
    handle_eof:
1314
        ist->pts= ist->next_pts;
1315

    
1316
        if(avpkt.size && avpkt.size != pkt->size &&
1317
           (!ist->showed_multi_packet_warning && verbose>0 || verbose>1)){
1318
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1319
            ist->showed_multi_packet_warning=1;
1320
        }
1321

    
1322
        /* decode the packet if needed */
1323
        decoded_data_buf = NULL; /* fail safe */
1324
        decoded_data_size= 0;
1325
        data_buf  = avpkt.data;
1326
        data_size = avpkt.size;
1327
        subtitle_to_free = NULL;
1328
        if (ist->decoding_needed) {
1329
            switch(ist->st->codec->codec_type) {
1330
            case CODEC_TYPE_AUDIO:{
1331
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1332
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1333
                    av_free(samples);
1334
                    samples= av_malloc(samples_size);
1335
                }
1336
                decoded_data_size= samples_size;
1337
                    /* XXX: could avoid copy if PCM 16 bits with same
1338
                       endianness as CPU */
1339
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1340
                                            &avpkt);
1341
                if (ret < 0)
1342
                    goto fail_decode;
1343
                avpkt.data += ret;
1344
                avpkt.size -= ret;
1345
                data_size   = ret;
1346
                /* Some bug in mpeg audio decoder gives */
1347
                /* decoded_data_size < 0, it seems they are overflows */
1348
                if (decoded_data_size <= 0) {
1349
                    /* no audio frame */
1350
                    continue;
1351
                }
1352
                decoded_data_buf = (uint8_t *)samples;
1353
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1354
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1355
                break;}
1356
            case CODEC_TYPE_VIDEO:
1357
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1358
                    /* XXX: allocate picture correctly */
1359
                    avcodec_get_frame_defaults(&picture);
1360

    
1361
                    ret = avcodec_decode_video2(ist->st->codec,
1362
                                                &picture, &got_picture, &avpkt);
1363
                    ist->st->quality= picture.quality;
1364
                    if (ret < 0)
1365
                        goto fail_decode;
1366
                    if (!got_picture) {
1367
                        /* no picture yet */
1368
                        goto discard_packet;
1369
                    }
1370
                    if (ist->st->codec->time_base.num != 0) {
1371
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1372
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1373
                                          ist->st->codec->time_base.num * ticks) /
1374
                            ist->st->codec->time_base.den;
1375
                    }
1376
                    avpkt.size = 0;
1377
                    break;
1378
            case CODEC_TYPE_SUBTITLE:
1379
                ret = avcodec_decode_subtitle2(ist->st->codec,
1380
                                               &subtitle, &got_subtitle, &avpkt);
1381
                if (ret < 0)
1382
                    goto fail_decode;
1383
                if (!got_subtitle) {
1384
                    goto discard_packet;
1385
                }
1386
                subtitle_to_free = &subtitle;
1387
                avpkt.size = 0;
1388
                break;
1389
            default:
1390
                goto fail_decode;
1391
            }
1392
        } else {
1393
            switch(ist->st->codec->codec_type) {
1394
            case CODEC_TYPE_AUDIO:
1395
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1396
                    ist->st->codec->sample_rate;
1397
                break;
1398
            case CODEC_TYPE_VIDEO:
1399
                if (ist->st->codec->time_base.num != 0) {
1400
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1401
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1402
                                      ist->st->codec->time_base.num * ticks) /
1403
                        ist->st->codec->time_base.den;
1404
                }
1405
                break;
1406
            }
1407
            ret = avpkt.size;
1408
            avpkt.size = 0;
1409
        }
1410

    
1411
        buffer_to_free = NULL;
1412
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1413
            pre_process_video_frame(ist, (AVPicture *)&picture,
1414
                                    &buffer_to_free);
1415
        }
1416

    
1417
        // preprocess audio (volume)
1418
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1419
            if (audio_volume != 256) {
1420
                short *volp;
1421
                volp = samples;
1422
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1423
                    int v = ((*volp) * audio_volume + 128) >> 8;
1424
                    if (v < -32768) v = -32768;
1425
                    if (v >  32767) v = 32767;
1426
                    *volp++ = v;
1427
                }
1428
            }
1429
        }
1430

    
1431
        /* frame rate emulation */
1432
        if (rate_emu) {
1433
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1434
            int64_t now = av_gettime() - ist->start;
1435
            if (pts > now)
1436
                usleep(pts - now);
1437
        }
1438

    
1439
        /* if output time reached then transcode raw format,
1440
           encode packets and output them */
1441
        if (start_time == 0 || ist->pts >= start_time)
1442
            for(i=0;i<nb_ostreams;i++) {
1443
                int frame_size;
1444

    
1445
                ost = ost_table[i];
1446
                if (ost->source_index == ist_index) {
1447
                    os = output_files[ost->file_index];
1448

    
1449
                    /* set the input output pts pairs */
1450
                    //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1451

    
1452
                    if (ost->encoding_needed) {
1453
                        assert(ist->decoding_needed);
1454
                        switch(ost->st->codec->codec_type) {
1455
                        case CODEC_TYPE_AUDIO:
1456
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1457
                            break;
1458
                        case CODEC_TYPE_VIDEO:
1459
                            do_video_out(os, ost, ist, &picture, &frame_size);
1460
                            if (vstats_filename && frame_size)
1461
                                do_video_stats(os, ost, frame_size);
1462
                            break;
1463
                        case CODEC_TYPE_SUBTITLE:
1464
                            do_subtitle_out(os, ost, ist, &subtitle,
1465
                                            pkt->pts);
1466
                            break;
1467
                        default:
1468
                            abort();
1469
                        }
1470
                    } else {
1471
                        AVFrame avframe; //FIXME/XXX remove this
1472
                        AVPacket opkt;
1473
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1474

    
1475
                        av_init_packet(&opkt);
1476

    
1477
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1478
                            continue;
1479

    
1480
                        /* no reencoding needed : output the packet directly */
1481
                        /* force the input stream PTS */
1482

    
1483
                        avcodec_get_frame_defaults(&avframe);
1484
                        ost->st->codec->coded_frame= &avframe;
1485
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1486

    
1487
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1488
                            audio_size += data_size;
1489
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1490
                            video_size += data_size;
1491
                            ost->sync_opts++;
1492
                        }
1493

    
1494
                        opkt.stream_index= ost->index;
1495
                        if(pkt->pts != AV_NOPTS_VALUE)
1496
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1497
                        else
1498
                            opkt.pts= AV_NOPTS_VALUE;
1499

    
1500
                        if (pkt->dts == AV_NOPTS_VALUE)
1501
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1502
                        else
1503
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1504
                        opkt.dts -= ost_tb_start_time;
1505

    
1506
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1507
                        opkt.flags= pkt->flags;
1508

    
1509
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1510
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1511
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1512
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1513
                           ) {
1514
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1515
                                opkt.destruct= av_destruct_packet;
1516
                        } else {
1517
                            opkt.data = data_buf;
1518
                            opkt.size = data_size;
1519
                        }
1520

    
1521
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1522
                        ost->st->codec->frame_number++;
1523
                        ost->frame_number++;
1524
                        av_free_packet(&opkt);
1525
                    }
1526
                }
1527
            }
1528
        av_free(buffer_to_free);
1529
        /* XXX: allocate the subtitles in the codec ? */
1530
        if (subtitle_to_free) {
1531
            if (subtitle_to_free->rects != NULL) {
1532
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1533
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1534
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1535
                    av_freep(&subtitle_to_free->rects[i]);
1536
                }
1537
                av_freep(&subtitle_to_free->rects);
1538
            }
1539
            subtitle_to_free->num_rects = 0;
1540
            subtitle_to_free = NULL;
1541
        }
1542
    }
1543
 discard_packet:
1544
    if (pkt == NULL) {
1545
        /* EOF handling */
1546

    
1547
        for(i=0;i<nb_ostreams;i++) {
1548
            ost = ost_table[i];
1549
            if (ost->source_index == ist_index) {
1550
                AVCodecContext *enc= ost->st->codec;
1551
                os = output_files[ost->file_index];
1552

    
1553
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1554
                    continue;
1555
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1556
                    continue;
1557

    
1558
                if (ost->encoding_needed) {
1559
                    for(;;) {
1560
                        AVPacket pkt;
1561
                        int fifo_bytes;
1562
                        av_init_packet(&pkt);
1563
                        pkt.stream_index= ost->index;
1564

    
1565
                        switch(ost->st->codec->codec_type) {
1566
                        case CODEC_TYPE_AUDIO:
1567
                            fifo_bytes = av_fifo_size(ost->fifo);
1568
                            ret = 0;
1569
                            /* encode any samples remaining in fifo */
1570
                            if (fifo_bytes > 0) {
1571
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1572
                                int fs_tmp = enc->frame_size;
1573

    
1574
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1575
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1576
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1577
                                } else { /* pad */
1578
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1579
                                    if (samples_size < frame_bytes)
1580
                                        av_exit(1);
1581
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1582
                                }
1583

    
1584
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1585
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1586
                                                          ost->st->time_base.num, enc->sample_rate);
1587
                                enc->frame_size = fs_tmp;
1588
                            }
1589
                            if(ret <= 0) {
1590
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1591
                            }
1592
                            if (ret < 0) {
1593
                                fprintf(stderr, "Audio encoding failed\n");
1594
                                av_exit(1);
1595
                            }
1596
                            audio_size += ret;
1597
                            pkt.flags |= PKT_FLAG_KEY;
1598
                            break;
1599
                        case CODEC_TYPE_VIDEO:
1600
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1601
                            if (ret < 0) {
1602
                                fprintf(stderr, "Video encoding failed\n");
1603
                                av_exit(1);
1604
                            }
1605
                            video_size += ret;
1606
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1607
                                pkt.flags |= PKT_FLAG_KEY;
1608
                            if (ost->logfile && enc->stats_out) {
1609
                                fprintf(ost->logfile, "%s", enc->stats_out);
1610
                            }
1611
                            break;
1612
                        default:
1613
                            ret=-1;
1614
                        }
1615

    
1616
                        if(ret<=0)
1617
                            break;
1618
                        pkt.data= bit_buffer;
1619
                        pkt.size= ret;
1620
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1621
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1622
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1623
                    }
1624
                }
1625
            }
1626
        }
1627
    }
1628

    
1629
    return 0;
1630
 fail_decode:
1631
    return -1;
1632
}
1633

    
1634
static void print_sdp(AVFormatContext **avc, int n)
1635
{
1636
    char sdp[2048];
1637

    
1638
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1639
    printf("SDP:\n%s\n", sdp);
1640
    fflush(stdout);
1641
}
1642

    
1643
static int stream_index_from_inputs(AVFormatContext **input_files,
1644
                                    int nb_input_files,
1645
                                    AVInputFile *file_table,
1646
                                    AVInputStream **ist_table,
1647
                                    enum CodecType type,
1648
                                    int programid)
1649
{
1650
    int p, q, z;
1651
    for(z=0; z<nb_input_files; z++) {
1652
        AVFormatContext *ic = input_files[z];
1653
        for(p=0; p<ic->nb_programs; p++) {
1654
            AVProgram *program = ic->programs[p];
1655
            if(program->id != programid)
1656
                continue;
1657
            for(q=0; q<program->nb_stream_indexes; q++) {
1658
                int sidx = program->stream_index[q];
1659
                int ris = file_table[z].ist_index + sidx;
1660
                if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1661
                    return ris;
1662
            }
1663
        }
1664
    }
1665

    
1666
    return -1;
1667
}
1668

    
1669
/*
1670
 * The following code is the main loop of the file converter
1671
 */
1672
static int av_encode(AVFormatContext **output_files,
1673
                     int nb_output_files,
1674
                     AVFormatContext **input_files,
1675
                     int nb_input_files,
1676
                     AVStreamMap *stream_maps, int nb_stream_maps)
1677
{
1678
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1679
    AVFormatContext *is, *os;
1680
    AVCodecContext *codec, *icodec;
1681
    AVOutputStream *ost, **ost_table = NULL;
1682
    AVInputStream *ist, **ist_table = NULL;
1683
    AVInputFile *file_table;
1684
    char error[1024];
1685
    int key;
1686
    int want_sdp = 1;
1687
    uint8_t no_packet[MAX_FILES]={0};
1688
    int no_packet_count=0;
1689

    
1690
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1691
    if (!file_table)
1692
        goto fail;
1693

    
1694
    /* input stream init */
1695
    j = 0;
1696
    for(i=0;i<nb_input_files;i++) {
1697
        is = input_files[i];
1698
        file_table[i].ist_index = j;
1699
        file_table[i].nb_streams = is->nb_streams;
1700
        j += is->nb_streams;
1701
    }
1702
    nb_istreams = j;
1703

    
1704
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1705
    if (!ist_table)
1706
        goto fail;
1707

    
1708
    for(i=0;i<nb_istreams;i++) {
1709
        ist = av_mallocz(sizeof(AVInputStream));
1710
        if (!ist)
1711
            goto fail;
1712
        ist_table[i] = ist;
1713
    }
1714
    j = 0;
1715
    for(i=0;i<nb_input_files;i++) {
1716
        is = input_files[i];
1717
        for(k=0;k<is->nb_streams;k++) {
1718
            ist = ist_table[j++];
1719
            ist->st = is->streams[k];
1720
            ist->file_index = i;
1721
            ist->index = k;
1722
            ist->discard = 1; /* the stream is discarded by default
1723
                                 (changed later) */
1724

    
1725
            if (rate_emu) {
1726
                ist->start = av_gettime();
1727
            }
1728
        }
1729
    }
1730

    
1731
    /* output stream init */
1732
    nb_ostreams = 0;
1733
    for(i=0;i<nb_output_files;i++) {
1734
        os = output_files[i];
1735
        if (!os->nb_streams) {
1736
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1737
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1738
            av_exit(1);
1739
        }
1740
        nb_ostreams += os->nb_streams;
1741
    }
1742
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1743
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1744
        av_exit(1);
1745
    }
1746

    
1747
    /* Sanity check the mapping args -- do the input files & streams exist? */
1748
    for(i=0;i<nb_stream_maps;i++) {
1749
        int fi = stream_maps[i].file_index;
1750
        int si = stream_maps[i].stream_index;
1751

    
1752
        if (fi < 0 || fi > nb_input_files - 1 ||
1753
            si < 0 || si > file_table[fi].nb_streams - 1) {
1754
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1755
            av_exit(1);
1756
        }
1757
        fi = stream_maps[i].sync_file_index;
1758
        si = stream_maps[i].sync_stream_index;
1759
        if (fi < 0 || fi > nb_input_files - 1 ||
1760
            si < 0 || si > file_table[fi].nb_streams - 1) {
1761
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1762
            av_exit(1);
1763
        }
1764
    }
1765

    
1766
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1767
    if (!ost_table)
1768
        goto fail;
1769
    for(i=0;i<nb_ostreams;i++) {
1770
        ost = av_mallocz(sizeof(AVOutputStream));
1771
        if (!ost)
1772
            goto fail;
1773
        ost_table[i] = ost;
1774
    }
1775

    
1776
    n = 0;
1777
    for(k=0;k<nb_output_files;k++) {
1778
        os = output_files[k];
1779
        for(i=0;i<os->nb_streams;i++,n++) {
1780
            int found;
1781
            ost = ost_table[n];
1782
            ost->file_index = k;
1783
            ost->index = i;
1784
            ost->st = os->streams[i];
1785
            if (nb_stream_maps > 0) {
1786
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1787
                    stream_maps[n].stream_index;
1788

    
1789
                /* Sanity check that the stream types match */
1790
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1791
                    int i= ost->file_index;
1792
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1793
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1794
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1795
                        ost->file_index, ost->index);
1796
                    av_exit(1);
1797
                }
1798

    
1799
            } else {
1800
                if(opt_programid) {
1801
                    found = 0;
1802
                    j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1803
                    if(j != -1) {
1804
                        ost->source_index = j;
1805
                        found = 1;
1806
                    }
1807
                } else {
1808
                    /* get corresponding input stream index : we select the first one with the right type */
1809
                    found = 0;
1810
                    for(j=0;j<nb_istreams;j++) {
1811
                        ist = ist_table[j];
1812
                        if (ist->discard &&
1813
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1814
                            ost->source_index = j;
1815
                            found = 1;
1816
                            break;
1817
                        }
1818
                    }
1819
                }
1820

    
1821
                if (!found) {
1822
                    if(! opt_programid) {
1823
                        /* try again and reuse existing stream */
1824
                        for(j=0;j<nb_istreams;j++) {
1825
                            ist = ist_table[j];
1826
                            if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1827
                                ost->source_index = j;
1828
                                found = 1;
1829
                            }
1830
                        }
1831
                    }
1832
                    if (!found) {
1833
                        int i= ost->file_index;
1834
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1835
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1836
                                ost->file_index, ost->index);
1837
                        av_exit(1);
1838
                    }
1839
                }
1840
            }
1841
            ist = ist_table[ost->source_index];
1842
            ist->discard = 0;
1843
            ost->sync_ist = (nb_stream_maps > 0) ?
1844
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1845
                         stream_maps[n].sync_stream_index] : ist;
1846
        }
1847
    }
1848

    
1849
    /* for each output stream, we compute the right encoding parameters */
1850
    for(i=0;i<nb_ostreams;i++) {
1851
        AVMetadataTag *lang;
1852
        ost = ost_table[i];
1853
        os = output_files[ost->file_index];
1854
        ist = ist_table[ost->source_index];
1855

    
1856
        codec = ost->st->codec;
1857
        icodec = ist->st->codec;
1858

    
1859
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1860
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1861
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1862

    
1863
        ost->st->disposition = ist->st->disposition;
1864
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1865
        codec->chroma_sample_location = icodec->chroma_sample_location;
1866

    
1867
        if (ost->st->stream_copy) {
1868
            /* if stream_copy is selected, no need to decode or encode */
1869
            codec->codec_id = icodec->codec_id;
1870
            codec->codec_type = icodec->codec_type;
1871

    
1872
            if(!codec->codec_tag){
1873
                if(   !os->oformat->codec_tag
1874
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1875
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1876
                    codec->codec_tag = icodec->codec_tag;
1877
            }
1878

    
1879
            codec->bit_rate = icodec->bit_rate;
1880
            codec->extradata= icodec->extradata;
1881
            codec->extradata_size= icodec->extradata_size;
1882
            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){
1883
                codec->time_base = icodec->time_base;
1884
                codec->time_base.num *= icodec->ticks_per_frame;
1885
            }else
1886
                codec->time_base = ist->st->time_base;
1887
            switch(codec->codec_type) {
1888
            case CODEC_TYPE_AUDIO:
1889
                if(audio_volume != 256) {
1890
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1891
                    av_exit(1);
1892
                }
1893
                codec->channel_layout = icodec->channel_layout;
1894
                codec->sample_rate = icodec->sample_rate;
1895
                codec->channels = icodec->channels;
1896
                codec->frame_size = icodec->frame_size;
1897
                codec->block_align= icodec->block_align;
1898
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1899
                    codec->block_align= 0;
1900
                if(codec->codec_id == CODEC_ID_AC3)
1901
                    codec->block_align= 0;
1902
                break;
1903
            case CODEC_TYPE_VIDEO:
1904
                codec->pix_fmt = icodec->pix_fmt;
1905
                codec->width = icodec->width;
1906
                codec->height = icodec->height;
1907
                codec->has_b_frames = icodec->has_b_frames;
1908
                break;
1909
            case CODEC_TYPE_SUBTITLE:
1910
                codec->width = icodec->width;
1911
                codec->height = icodec->height;
1912
                break;
1913
            default:
1914
                abort();
1915
            }
1916
        } else {
1917
            switch(codec->codec_type) {
1918
            case CODEC_TYPE_AUDIO:
1919
                ost->fifo= av_fifo_alloc(1024);
1920
                if(!ost->fifo)
1921
                    goto fail;
1922
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1923
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1924
                icodec->request_channels = codec->channels;
1925
                ist->decoding_needed = 1;
1926
                ost->encoding_needed = 1;
1927
                break;
1928
            case CODEC_TYPE_VIDEO:
1929
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1930
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1931
                    av_exit(1);
1932
                }
1933
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1934
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1935
                ost->video_resample = ((codec->width != icodec->width -
1936
                                (frame_leftBand + frame_rightBand) +
1937
                                (frame_padleft + frame_padright)) ||
1938
                        (codec->height != icodec->height -
1939
                                (frame_topBand  + frame_bottomBand) +
1940
                                (frame_padtop + frame_padbottom)) ||
1941
                        (codec->pix_fmt != icodec->pix_fmt));
1942
                if (ost->video_crop) {
1943
                    ost->topBand    = ost->original_topBand    = frame_topBand;
1944
                    ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
1945
                    ost->leftBand   = ost->original_leftBand   = frame_leftBand;
1946
                    ost->rightBand  = ost->original_rightBand  = frame_rightBand;
1947
                }
1948
                if (ost->video_pad) {
1949
                    ost->padtop = frame_padtop;
1950
                    ost->padleft = frame_padleft;
1951
                    ost->padbottom = frame_padbottom;
1952
                    ost->padright = frame_padright;
1953
                    if (!ost->video_resample) {
1954
                        avcodec_get_frame_defaults(&ost->pict_tmp);
1955
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1956
                                         codec->width, codec->height))
1957
                            goto fail;
1958
                    }
1959
                }
1960
                if (ost->video_resample) {
1961
                    avcodec_get_frame_defaults(&ost->pict_tmp);
1962
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1963
                                         codec->width, codec->height)) {
1964
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1965
                        av_exit(1);
1966
                    }
1967
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1968
                    ost->img_resample_ctx = sws_getContext(
1969
                            icodec->width - (frame_leftBand + frame_rightBand),
1970
                            icodec->height - (frame_topBand + frame_bottomBand),
1971
                            icodec->pix_fmt,
1972
                            codec->width - (frame_padleft + frame_padright),
1973
                            codec->height - (frame_padtop + frame_padbottom),
1974
                            codec->pix_fmt,
1975
                            sws_flags, NULL, NULL, NULL);
1976
                    if (ost->img_resample_ctx == NULL) {
1977
                        fprintf(stderr, "Cannot get resampling context\n");
1978
                        av_exit(1);
1979
                    }
1980

    
1981
                    ost->original_height = icodec->height;
1982
                    ost->original_width  = icodec->width;
1983

    
1984
                    codec->bits_per_raw_sample= 0;
1985
                }
1986
                ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
1987
                ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
1988
                ost->resample_pix_fmt= icodec->pix_fmt;
1989
                ost->encoding_needed = 1;
1990
                ist->decoding_needed = 1;
1991
                break;
1992
            case CODEC_TYPE_SUBTITLE:
1993
                ost->encoding_needed = 1;
1994
                ist->decoding_needed = 1;
1995
                break;
1996
            default:
1997
                abort();
1998
                break;
1999
            }
2000
            /* two pass mode */
2001
            if (ost->encoding_needed &&
2002
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2003
                char logfilename[1024];
2004
                FILE *f;
2005
                int size;
2006
                char *logbuffer;
2007

    
2008
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2009
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2010
                         i);
2011
                if (codec->flags & CODEC_FLAG_PASS1) {
2012
                    f = fopen(logfilename, "w");
2013
                    if (!f) {
2014
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2015
                        av_exit(1);
2016
                    }
2017
                    ost->logfile = f;
2018
                } else {
2019
                    /* read the log file */
2020
                    f = fopen(logfilename, "r");
2021
                    if (!f) {
2022
                        fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
2023
                        av_exit(1);
2024
                    }
2025
                    fseek(f, 0, SEEK_END);
2026
                    size = ftell(f);
2027
                    fseek(f, 0, SEEK_SET);
2028
                    logbuffer = av_malloc(size + 1);
2029
                    if (!logbuffer) {
2030
                        fprintf(stderr, "Could not allocate log buffer\n");
2031
                        av_exit(1);
2032
                    }
2033
                    size = fread(logbuffer, 1, size, f);
2034
                    fclose(f);
2035
                    logbuffer[size] = '\0';
2036
                    codec->stats_in = logbuffer;
2037
                }
2038
            }
2039
        }
2040
        if(codec->codec_type == CODEC_TYPE_VIDEO){
2041
            int size= codec->width * codec->height;
2042
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2043
        }
2044
    }
2045

    
2046
    if (!bit_buffer)
2047
        bit_buffer = av_malloc(bit_buffer_size);
2048
    if (!bit_buffer) {
2049
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2050
                bit_buffer_size);
2051
        ret = AVERROR(ENOMEM);
2052
        goto fail;
2053
    }
2054

    
2055
    /* open each encoder */
2056
    for(i=0;i<nb_ostreams;i++) {
2057
        ost = ost_table[i];
2058
        if (ost->encoding_needed) {
2059
            AVCodec *codec = output_codecs[i];
2060
            if (!codec)
2061
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2062
            if (!codec) {
2063
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2064
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2065
                ret = AVERROR(EINVAL);
2066
                goto dump_format;
2067
            }
2068
            if (avcodec_open(ost->st->codec, codec) < 0) {
2069
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2070
                        ost->file_index, ost->index);
2071
                ret = AVERROR(EINVAL);
2072
                goto dump_format;
2073
            }
2074
            extra_size += ost->st->codec->extradata_size;
2075
        }
2076
    }
2077

    
2078
    /* open each decoder */
2079
    for(i=0;i<nb_istreams;i++) {
2080
        ist = ist_table[i];
2081
        if (ist->decoding_needed) {
2082
            AVCodec *codec = input_codecs[i];
2083
            if (!codec)
2084
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2085
            if (!codec) {
2086
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2087
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2088
                ret = AVERROR(EINVAL);
2089
                goto dump_format;
2090
            }
2091
            if (avcodec_open(ist->st->codec, codec) < 0) {
2092
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2093
                        ist->file_index, ist->index);
2094
                ret = AVERROR(EINVAL);
2095
                goto dump_format;
2096
            }
2097
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2098
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2099
        }
2100
    }
2101

    
2102
    /* init pts */
2103
    for(i=0;i<nb_istreams;i++) {
2104
        ist = ist_table[i];
2105
        ist->pts = 0;
2106
        ist->next_pts = AV_NOPTS_VALUE;
2107
        ist->is_start = 1;
2108
    }
2109

    
2110
    /* set the duration of the output to the duration of the input
2111
     * if the output ends up being different, it'll be corrected later */
2112
    for (i=0;i<nb_output_files;i++) {
2113
        AVFormatContext *out_file = output_files[i];
2114
        AVFormatContext *in_file = input_files[i];
2115

    
2116
        if (recording_time != INT64_MAX) {
2117
            out_file->duration = recording_time / 1000000 * AV_TIME_BASE;
2118
        } else {
2119
            out_file->duration = in_file->duration;
2120
        }
2121
    }
2122

    
2123
    /* set meta data information from input file if required */
2124
    for (i=0;i<nb_meta_data_maps;i++) {
2125
        AVFormatContext *out_file;
2126
        AVFormatContext *in_file;
2127
        AVMetadataTag *mtag;
2128

    
2129
        int out_file_index = meta_data_maps[i].out_file;
2130
        int in_file_index = meta_data_maps[i].in_file;
2131
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2132
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2133
                     out_file_index, out_file_index, in_file_index);
2134
            ret = AVERROR(EINVAL);
2135
            goto dump_format;
2136
        }
2137
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2138
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2139
                     in_file_index, out_file_index, in_file_index);
2140
            ret = AVERROR(EINVAL);
2141
            goto dump_format;
2142
        }
2143

    
2144
        out_file = output_files[out_file_index];
2145
        in_file = input_files[in_file_index];
2146

    
2147

    
2148
        mtag=NULL;
2149
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2150
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2151
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2152
                                    in_file->iformat->metadata_conv);
2153
    }
2154

    
2155
    /* open files and write file headers */
2156
    for(i=0;i<nb_output_files;i++) {
2157
        os = output_files[i];
2158
        if (av_write_header(os) < 0) {
2159
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2160
            ret = AVERROR(EINVAL);
2161
            goto dump_format;
2162
        }
2163
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2164
            want_sdp = 0;
2165
        }
2166
    }
2167

    
2168
 dump_format:
2169
    /* dump the file output parameters - cannot be done before in case
2170
       of stream copy */
2171
    for(i=0;i<nb_output_files;i++) {
2172
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2173
    }
2174

    
2175
    /* dump the stream mapping */
2176
    if (verbose >= 0) {
2177
        fprintf(stderr, "Stream mapping:\n");
2178
        for(i=0;i<nb_ostreams;i++) {
2179
            ost = ost_table[i];
2180
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2181
                    ist_table[ost->source_index]->file_index,
2182
                    ist_table[ost->source_index]->index,
2183
                    ost->file_index,
2184
                    ost->index);
2185
            if (ost->sync_ist != ist_table[ost->source_index])
2186
                fprintf(stderr, " [sync #%d.%d]",
2187
                        ost->sync_ist->file_index,
2188
                        ost->sync_ist->index);
2189
            fprintf(stderr, "\n");
2190
        }
2191
    }
2192

    
2193
    if (ret) {
2194
        fprintf(stderr, "%s\n", error);
2195
        goto fail;
2196
    }
2197

    
2198
    if (want_sdp) {
2199
        print_sdp(output_files, nb_output_files);
2200
    }
2201

    
2202
    if (!using_stdin && verbose >= 0) {
2203
        fprintf(stderr, "Press [q] to stop encoding\n");
2204
        url_set_interrupt_cb(decode_interrupt_cb);
2205
    }
2206
    term_init();
2207

    
2208
    timer_start = av_gettime();
2209

    
2210
    for(; received_sigterm == 0;) {
2211
        int file_index, ist_index;
2212
        AVPacket pkt;
2213
        double ipts_min;
2214
        double opts_min;
2215

    
2216
    redo:
2217
        ipts_min= 1e100;
2218
        opts_min= 1e100;
2219
        /* if 'q' pressed, exits */
2220
        if (!using_stdin) {
2221
            if (q_pressed)
2222
                break;
2223
            /* read_key() returns 0 on EOF */
2224
            key = read_key();
2225
            if (key == 'q')
2226
                break;
2227
        }
2228

    
2229
        /* select the stream that we must read now by looking at the
2230
           smallest output pts */
2231
        file_index = -1;
2232
        for(i=0;i<nb_ostreams;i++) {
2233
            double ipts, opts;
2234
            ost = ost_table[i];
2235
            os = output_files[ost->file_index];
2236
            ist = ist_table[ost->source_index];
2237
            if(no_packet[ist->file_index])
2238
                continue;
2239
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2240
            ipts = (double)ist->pts;
2241
            if (!file_table[ist->file_index].eof_reached){
2242
                if(ipts < ipts_min) {
2243
                    ipts_min = ipts;
2244
                    if(input_sync ) file_index = ist->file_index;
2245
                }
2246
                if(opts < opts_min) {
2247
                    opts_min = opts;
2248
                    if(!input_sync) file_index = ist->file_index;
2249
                }
2250
            }
2251
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2252
                file_index= -1;
2253
                break;
2254
            }
2255
        }
2256
        /* if none, if is finished */
2257
        if (file_index < 0) {
2258
            if(no_packet_count){
2259
                no_packet_count=0;
2260
                memset(no_packet, 0, sizeof(no_packet));
2261
                usleep(10000);
2262
                continue;
2263
            }
2264
            break;
2265
        }
2266

    
2267
        /* finish if recording time exhausted */
2268
        if (opts_min >= (recording_time / 1000000.0))
2269
            break;
2270

    
2271
        /* finish if limit size exhausted */
2272
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2273
            break;
2274

    
2275
        /* read a frame from it and output it in the fifo */
2276
        is = input_files[file_index];
2277
        ret= av_read_frame(is, &pkt);
2278
        if(ret == AVERROR(EAGAIN)){
2279
            no_packet[file_index]=1;
2280
            no_packet_count++;
2281
            continue;
2282
        }
2283
        if (ret < 0) {
2284
            file_table[file_index].eof_reached = 1;
2285
            if (opt_shortest)
2286
                break;
2287
            else
2288
                continue;
2289
        }
2290

    
2291
        no_packet_count=0;
2292
        memset(no_packet, 0, sizeof(no_packet));
2293

    
2294
        if (do_pkt_dump) {
2295
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2296
        }
2297
        /* the following test is needed in case new streams appear
2298
           dynamically in stream : we ignore them */
2299
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2300
            goto discard_packet;
2301
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2302
        ist = ist_table[ist_index];
2303
        if (ist->discard)
2304
            goto discard_packet;
2305

    
2306
        if (pkt.dts != AV_NOPTS_VALUE)
2307
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2308
        if (pkt.pts != AV_NOPTS_VALUE)
2309
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2310

    
2311
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2312
            if(pkt.pts != AV_NOPTS_VALUE)
2313
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2314
            if(pkt.dts != AV_NOPTS_VALUE)
2315
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2316
        }
2317

    
2318
//        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);
2319
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2320
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2321
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2322
            int64_t delta= pkt_dts - ist->next_pts;
2323
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2324
                input_files_ts_offset[ist->file_index]-= delta;
2325
                if (verbose > 2)
2326
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2327
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2328
                if(pkt.pts != AV_NOPTS_VALUE)
2329
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2330
            }
2331
        }
2332

    
2333
        /* finish if recording time exhausted */
2334
        if (pkt.pts * av_q2d(ist->st->time_base) >= (recording_time / 1000000.0))
2335
            goto discard_packet;
2336

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

    
2340
            if (verbose >= 0)
2341
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2342
                        ist->file_index, ist->index);
2343
            if (exit_on_error)
2344
                av_exit(1);
2345
            av_free_packet(&pkt);
2346
            goto redo;
2347
        }
2348

    
2349
    discard_packet:
2350
        av_free_packet(&pkt);
2351

    
2352
        /* dump report by using the output first video and audio streams */
2353
        print_report(output_files, ost_table, nb_ostreams, 0);
2354
    }
2355

    
2356
    /* at the end of stream, we must flush the decoder buffers */
2357
    for(i=0;i<nb_istreams;i++) {
2358
        ist = ist_table[i];
2359
        if (ist->decoding_needed) {
2360
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2361
        }
2362
    }
2363

    
2364
    term_exit();
2365

    
2366
    /* write the trailer if needed and close file */
2367
    for(i=0;i<nb_output_files;i++) {
2368
        os = output_files[i];
2369
        av_write_trailer(os);
2370
    }
2371

    
2372
    /* dump report by using the first video and audio streams */
2373
    print_report(output_files, ost_table, nb_ostreams, 1);
2374

    
2375
    /* close each encoder */
2376
    for(i=0;i<nb_ostreams;i++) {
2377
        ost = ost_table[i];
2378
        if (ost->encoding_needed) {
2379
            av_freep(&ost->st->codec->stats_in);
2380
            avcodec_close(ost->st->codec);
2381
        }
2382
    }
2383

    
2384
    /* close each decoder */
2385
    for(i=0;i<nb_istreams;i++) {
2386
        ist = ist_table[i];
2387
        if (ist->decoding_needed) {
2388
            avcodec_close(ist->st->codec);
2389
        }
2390
    }
2391

    
2392
    /* finished ! */
2393
    ret = 0;
2394

    
2395
 fail:
2396
    av_freep(&bit_buffer);
2397
    av_free(file_table);
2398

    
2399
    if (ist_table) {
2400
        for(i=0;i<nb_istreams;i++) {
2401
            ist = ist_table[i];
2402
            av_free(ist);
2403
        }
2404
        av_free(ist_table);
2405
    }
2406
    if (ost_table) {
2407
        for(i=0;i<nb_ostreams;i++) {
2408
            ost = ost_table[i];
2409
            if (ost) {
2410
                if (ost->logfile) {
2411
                    fclose(ost->logfile);
2412
                    ost->logfile = NULL;
2413
                }
2414
                av_fifo_free(ost->fifo); /* works even if fifo is not
2415
                                             initialized but set to zero */
2416
                av_free(ost->pict_tmp.data[0]);
2417
                if (ost->video_resample)
2418
                    sws_freeContext(ost->img_resample_ctx);
2419
                if (ost->resample)
2420
                    audio_resample_close(ost->resample);
2421
                if (ost->reformat_ctx)
2422
                    av_audio_convert_free(ost->reformat_ctx);
2423
                av_free(ost);
2424
            }
2425
        }
2426
        av_free(ost_table);
2427
    }
2428
    return ret;
2429
}
2430

    
2431
static void opt_format(const char *arg)
2432
{
2433
    /* compatibility stuff for pgmyuv */
2434
    if (!strcmp(arg, "pgmyuv")) {
2435
        pgmyuv_compatibility_hack=1;
2436
//        opt_image_format(arg);
2437
        arg = "image2";
2438
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2439
    }
2440

    
2441
    last_asked_format = arg;
2442
}
2443

    
2444
static void opt_video_rc_override_string(const char *arg)
2445
{
2446
    video_rc_override_string = arg;
2447
}
2448

    
2449
static int opt_me_threshold(const char *opt, const char *arg)
2450
{
2451
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2452
    return 0;
2453
}
2454

    
2455
static int opt_verbose(const char *opt, const char *arg)
2456
{
2457
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2458
    return 0;
2459
}
2460

    
2461
static int opt_frame_rate(const char *opt, const char *arg)
2462
{
2463
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2464
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2465
        av_exit(1);
2466
    }
2467
    return 0;
2468
}
2469

    
2470
static int opt_bitrate(const char *opt, const char *arg)
2471
{
2472
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2473

    
2474
    opt_default(opt, arg);
2475

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

    
2479
    return 0;
2480
}
2481

    
2482
static void opt_frame_crop_top(const char *arg)
2483
{
2484
    frame_topBand = atoi(arg);
2485
    if (frame_topBand < 0) {
2486
        fprintf(stderr, "Incorrect top crop size\n");
2487
        av_exit(1);
2488
    }
2489
    if ((frame_topBand) >= frame_height){
2490
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2491
        av_exit(1);
2492
    }
2493
    frame_height -= frame_topBand;
2494
}
2495

    
2496
static void opt_frame_crop_bottom(const char *arg)
2497
{
2498
    frame_bottomBand = atoi(arg);
2499
    if (frame_bottomBand < 0) {
2500
        fprintf(stderr, "Incorrect bottom crop size\n");
2501
        av_exit(1);
2502
    }
2503
    if ((frame_bottomBand) >= frame_height){
2504
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2505
        av_exit(1);
2506
    }
2507
    frame_height -= frame_bottomBand;
2508
}
2509

    
2510
static void opt_frame_crop_left(const char *arg)
2511
{
2512
    frame_leftBand = atoi(arg);
2513
    if (frame_leftBand < 0) {
2514
        fprintf(stderr, "Incorrect left crop size\n");
2515
        av_exit(1);
2516
    }
2517
    if ((frame_leftBand) >= frame_width){
2518
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2519
        av_exit(1);
2520
    }
2521
    frame_width -= frame_leftBand;
2522
}
2523

    
2524
static void opt_frame_crop_right(const char *arg)
2525
{
2526
    frame_rightBand = atoi(arg);
2527
    if (frame_rightBand < 0) {
2528
        fprintf(stderr, "Incorrect right crop size\n");
2529
        av_exit(1);
2530
    }
2531
    if ((frame_rightBand) >= frame_width){
2532
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2533
        av_exit(1);
2534
    }
2535
    frame_width -= frame_rightBand;
2536
}
2537

    
2538
static void opt_frame_size(const char *arg)
2539
{
2540
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2541
        fprintf(stderr, "Incorrect frame size\n");
2542
        av_exit(1);
2543
    }
2544
}
2545

    
2546
static void opt_pad_color(const char *arg) {
2547
    /* Input is expected to be six hex digits similar to
2548
       how colors are expressed in html tags (but without the #) */
2549
    int rgb = strtol(arg, NULL, 16);
2550
    int r,g,b;
2551

    
2552
    r = (rgb >> 16);
2553
    g = ((rgb >> 8) & 255);
2554
    b = (rgb & 255);
2555

    
2556
    padcolor[0] = RGB_TO_Y(r,g,b);
2557
    padcolor[1] = RGB_TO_U(r,g,b,0);
2558
    padcolor[2] = RGB_TO_V(r,g,b,0);
2559
}
2560

    
2561
static void opt_frame_pad_top(const char *arg)
2562
{
2563
    frame_padtop = atoi(arg);
2564
    if (frame_padtop < 0) {
2565
        fprintf(stderr, "Incorrect top pad size\n");
2566
        av_exit(1);
2567
    }
2568
}
2569

    
2570
static void opt_frame_pad_bottom(const char *arg)
2571
{
2572
    frame_padbottom = atoi(arg);
2573
    if (frame_padbottom < 0) {
2574
        fprintf(stderr, "Incorrect bottom pad size\n");
2575
        av_exit(1);
2576
    }
2577
}
2578

    
2579

    
2580
static void opt_frame_pad_left(const char *arg)
2581
{
2582
    frame_padleft = atoi(arg);
2583
    if (frame_padleft < 0) {
2584
        fprintf(stderr, "Incorrect left pad size\n");
2585
        av_exit(1);
2586
    }
2587
}
2588

    
2589

    
2590
static void opt_frame_pad_right(const char *arg)
2591
{
2592
    frame_padright = atoi(arg);
2593
    if (frame_padright < 0) {
2594
        fprintf(stderr, "Incorrect right pad size\n");
2595
        av_exit(1);
2596
    }
2597
}
2598

    
2599
static void opt_frame_pix_fmt(const char *arg)
2600
{
2601
    if (strcmp(arg, "list")) {
2602
        frame_pix_fmt = av_get_pix_fmt(arg);
2603
        if (frame_pix_fmt == PIX_FMT_NONE) {
2604
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2605
            av_exit(1);
2606
        }
2607
    } else {
2608
        show_pix_fmts();
2609
        av_exit(0);
2610
    }
2611
}
2612

    
2613
static void opt_frame_aspect_ratio(const char *arg)
2614
{
2615
    int x = 0, y = 0;
2616
    double ar = 0;
2617
    const char *p;
2618
    char *end;
2619

    
2620
    p = strchr(arg, ':');
2621
    if (p) {
2622
        x = strtol(arg, &end, 10);
2623
        if (end == p)
2624
            y = strtol(end+1, &end, 10);
2625
        if (x > 0 && y > 0)
2626
            ar = (double)x / (double)y;
2627
    } else
2628
        ar = strtod(arg, NULL);
2629

    
2630
    if (!ar) {
2631
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2632
        av_exit(1);
2633
    }
2634
    frame_aspect_ratio = ar;
2635
}
2636

    
2637
static int opt_metadata(const char *opt, const char *arg)
2638
{
2639
    char *mid= strchr(arg, '=');
2640

    
2641
    if(!mid){
2642
        fprintf(stderr, "Missing =\n");
2643
        av_exit(1);
2644
    }
2645
    *mid++= 0;
2646

    
2647
    metadata_count++;
2648
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2649
    metadata[metadata_count-1].key  = av_strdup(arg);
2650
    metadata[metadata_count-1].value= av_strdup(mid);
2651

    
2652
    return 0;
2653
}
2654

    
2655
static void opt_qscale(const char *arg)
2656
{
2657
    video_qscale = atof(arg);
2658
    if (video_qscale <= 0 ||
2659
        video_qscale > 255) {
2660
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2661
        av_exit(1);
2662
    }
2663
}
2664

    
2665
static void opt_top_field_first(const char *arg)
2666
{
2667
    top_field_first= atoi(arg);
2668
}
2669

    
2670
static int opt_thread_count(const char *opt, const char *arg)
2671
{
2672
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2673
#if !HAVE_THREADS
2674
    if (verbose >= 0)
2675
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2676
#endif
2677
    return 0;
2678
}
2679

    
2680
static void opt_audio_sample_fmt(const char *arg)
2681
{
2682
    if (strcmp(arg, "list"))
2683
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2684
    else {
2685
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2686
        av_exit(0);
2687
    }
2688
}
2689

    
2690
static int opt_audio_rate(const char *opt, const char *arg)
2691
{
2692
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2693
    return 0;
2694
}
2695

    
2696
static int opt_audio_channels(const char *opt, const char *arg)
2697
{
2698
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2699
    return 0;
2700
}
2701

    
2702
static void opt_video_channel(const char *arg)
2703
{
2704
    video_channel = strtol(arg, NULL, 0);
2705
}
2706

    
2707
static void opt_video_standard(const char *arg)
2708
{
2709
    video_standard = av_strdup(arg);
2710
}
2711

    
2712
static void opt_codec(int *pstream_copy, char **pcodec_name,
2713
                      int codec_type, const char *arg)
2714
{
2715
    av_freep(pcodec_name);
2716
    if (!strcmp(arg, "copy")) {
2717
        *pstream_copy = 1;
2718
    } else {
2719
        *pcodec_name = av_strdup(arg);
2720
    }
2721
}
2722

    
2723
static void opt_audio_codec(const char *arg)
2724
{
2725
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2726
}
2727

    
2728
static void opt_audio_tag(const char *arg)
2729
{
2730
    char *tail;
2731
    audio_codec_tag= strtol(arg, &tail, 0);
2732

    
2733
    if(!tail || *tail)
2734
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2735
}
2736

    
2737
static void opt_video_tag(const char *arg)
2738
{
2739
    char *tail;
2740
    video_codec_tag= strtol(arg, &tail, 0);
2741

    
2742
    if(!tail || *tail)
2743
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2744
}
2745

    
2746
static void opt_video_codec(const char *arg)
2747
{
2748
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2749
}
2750

    
2751
static void opt_subtitle_codec(const char *arg)
2752
{
2753
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2754
}
2755

    
2756
static void opt_subtitle_tag(const char *arg)
2757
{
2758
    char *tail;
2759
    subtitle_codec_tag= strtol(arg, &tail, 0);
2760

    
2761
    if(!tail || *tail)
2762
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2763
}
2764

    
2765
static void opt_map(const char *arg)
2766
{
2767
    AVStreamMap *m;
2768
    char *p;
2769

    
2770
    m = &stream_maps[nb_stream_maps++];
2771

    
2772
    m->file_index = strtol(arg, &p, 0);
2773
    if (*p)
2774
        p++;
2775

    
2776
    m->stream_index = strtol(p, &p, 0);
2777
    if (*p) {
2778
        p++;
2779
        m->sync_file_index = strtol(p, &p, 0);
2780
        if (*p)
2781
            p++;
2782
        m->sync_stream_index = strtol(p, &p, 0);
2783
    } else {
2784
        m->sync_file_index = m->file_index;
2785
        m->sync_stream_index = m->stream_index;
2786
    }
2787
}
2788

    
2789
static void opt_map_meta_data(const char *arg)
2790
{
2791
    AVMetaDataMap *m;
2792
    char *p;
2793

    
2794
    m = &meta_data_maps[nb_meta_data_maps++];
2795

    
2796
    m->out_file = strtol(arg, &p, 0);
2797
    if (*p)
2798
        p++;
2799

    
2800
    m->in_file = strtol(p, &p, 0);
2801
}
2802

    
2803
static void opt_input_ts_scale(const char *arg)
2804
{
2805
    unsigned int stream;
2806
    double scale;
2807
    char *p;
2808

    
2809
    stream = strtol(arg, &p, 0);
2810
    if (*p)
2811
        p++;
2812
    scale= strtod(p, &p);
2813

    
2814
    if(stream >= MAX_STREAMS)
2815
        av_exit(1);
2816

    
2817
    input_files_ts_scale[nb_input_files][stream]= scale;
2818
}
2819

    
2820
static int opt_recording_time(const char *opt, const char *arg)
2821
{
2822
    recording_time = parse_time_or_die(opt, arg, 1);
2823
    return 0;
2824
}
2825

    
2826
static int opt_start_time(const char *opt, const char *arg)
2827
{
2828
    start_time = parse_time_or_die(opt, arg, 1);
2829
    return 0;
2830
}
2831

    
2832
static int opt_rec_timestamp(const char *opt, const char *arg)
2833
{
2834
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2835
    return 0;
2836
}
2837

    
2838
static int opt_input_ts_offset(const char *opt, const char *arg)
2839
{
2840
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2841
    return 0;
2842
}
2843

    
2844
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2845
{
2846
    const char *codec_string = encoder ? "encoder" : "decoder";
2847
    AVCodec *codec;
2848

    
2849
    if(!name)
2850
        return CODEC_ID_NONE;
2851
    codec = encoder ?
2852
        avcodec_find_encoder_by_name(name) :
2853
        avcodec_find_decoder_by_name(name);
2854
    if(!codec) {
2855
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2856
        av_exit(1);
2857
    }
2858
    if(codec->type != type) {
2859
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2860
        av_exit(1);
2861
    }
2862
    return codec->id;
2863
}
2864

    
2865
static void opt_input_file(const char *filename)
2866
{
2867
    AVFormatContext *ic;
2868
    AVFormatParameters params, *ap = &params;
2869
    AVInputFormat *file_iformat = NULL;
2870
    int err, i, ret, rfps, rfps_base;
2871
    int64_t timestamp;
2872

    
2873
    if (last_asked_format) {
2874
        file_iformat = av_find_input_format(last_asked_format);
2875
        last_asked_format = NULL;
2876
    }
2877

    
2878
    if (!strcmp(filename, "-"))
2879
        filename = "pipe:";
2880

    
2881
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2882
                    !strcmp(filename, "/dev/stdin");
2883

    
2884
    /* get default parameters from command line */
2885
    ic = avformat_alloc_context();
2886
    if (!ic) {
2887
        print_error(filename, AVERROR(ENOMEM));
2888
        av_exit(1);
2889
    }
2890

    
2891
    memset(ap, 0, sizeof(*ap));
2892
    ap->prealloced_context = 1;
2893
    ap->sample_rate = audio_sample_rate;
2894
    ap->channels = audio_channels;
2895
    ap->time_base.den = frame_rate.num;
2896
    ap->time_base.num = frame_rate.den;
2897
    ap->width = frame_width + frame_padleft + frame_padright;
2898
    ap->height = frame_height + frame_padtop + frame_padbottom;
2899
    ap->pix_fmt = frame_pix_fmt;
2900
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2901
    ap->channel = video_channel;
2902
    ap->standard = video_standard;
2903

    
2904
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2905

    
2906
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2907
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2908
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2909
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2910

    
2911
    if(pgmyuv_compatibility_hack)
2912
        ic->video_codec_id= CODEC_ID_PGMYUV;
2913

    
2914
    /* open the input file with generic libav function */
2915
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2916
    if (err < 0) {
2917
        print_error(filename, err);
2918
        av_exit(1);
2919
    }
2920
    if(opt_programid) {
2921
        int i;
2922
        for(i=0; i<ic->nb_programs; i++)
2923
            if(ic->programs[i]->id != opt_programid)
2924
                ic->programs[i]->discard = AVDISCARD_ALL;
2925
    }
2926

    
2927
    ic->loop_input = loop_input;
2928

    
2929
    /* If not enough info to get the stream parameters, we decode the
2930
       first frames to get it. (used in mpeg case for example) */
2931
    ret = av_find_stream_info(ic);
2932
    if (ret < 0 && verbose >= 0) {
2933
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2934
        av_exit(1);
2935
    }
2936

    
2937
    timestamp = start_time;
2938
    /* add the stream start time */
2939
    if (ic->start_time != AV_NOPTS_VALUE)
2940
        timestamp += ic->start_time;
2941

    
2942
    /* if seeking requested, we execute it */
2943
    if (start_time != 0) {
2944
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2945
        if (ret < 0) {
2946
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2947
                    filename, (double)timestamp / AV_TIME_BASE);
2948
        }
2949
        /* reset seek info */
2950
        start_time = 0;
2951
    }
2952

    
2953
    /* update the current parameters so that they match the one of the input stream */
2954
    for(i=0;i<ic->nb_streams;i++) {
2955
        AVStream *st = ic->streams[i];
2956
        AVCodecContext *enc = st->codec;
2957
        avcodec_thread_init(enc, thread_count);
2958
        switch(enc->codec_type) {
2959
        case CODEC_TYPE_AUDIO:
2960
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2961
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2962
            channel_layout = enc->channel_layout;
2963
            audio_channels = enc->channels;
2964
            audio_sample_rate = enc->sample_rate;
2965
            audio_sample_fmt = enc->sample_fmt;
2966
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2967
            if(audio_disable)
2968
                st->discard= AVDISCARD_ALL;
2969
            break;
2970
        case CODEC_TYPE_VIDEO:
2971
            set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2972
            frame_height = enc->height;
2973
            frame_width = enc->width;
2974
            if(ic->streams[i]->sample_aspect_ratio.num)
2975
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2976
            else
2977
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2978
            frame_aspect_ratio *= (float) enc->width / enc->height;
2979
            frame_pix_fmt = enc->pix_fmt;
2980
            rfps      = ic->streams[i]->r_frame_rate.num;
2981
            rfps_base = ic->streams[i]->r_frame_rate.den;
2982
            if(enc->lowres) {
2983
                enc->flags |= CODEC_FLAG_EMU_EDGE;
2984
                frame_height >>= enc->lowres;
2985
                frame_width  >>= enc->lowres;
2986
            }
2987
            if(me_threshold)
2988
                enc->debug |= FF_DEBUG_MV;
2989

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

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

    
2996
                    (float)rfps / rfps_base, rfps, rfps_base);
2997
            }
2998
            /* update the current frame rate to match the stream frame rate */
2999
            frame_rate.num = rfps;
3000
            frame_rate.den = rfps_base;
3001

    
3002
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3003
            if(video_disable)
3004
                st->discard= AVDISCARD_ALL;
3005
            else if(video_discard)
3006
                st->discard= video_discard;
3007
            break;
3008
        case CODEC_TYPE_DATA:
3009
            break;
3010
        case CODEC_TYPE_SUBTITLE:
3011
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3012
            if(subtitle_disable)
3013
                st->discard = AVDISCARD_ALL;
3014
            break;
3015
        case CODEC_TYPE_ATTACHMENT:
3016
        case CODEC_TYPE_UNKNOWN:
3017
            nb_icodecs++;
3018
            break;
3019
        default:
3020
            abort();
3021
        }
3022
    }
3023

    
3024
    input_files[nb_input_files] = ic;
3025
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3026
    /* dump the file content */
3027
    if (verbose >= 0)
3028
        dump_format(ic, nb_input_files, filename, 0);
3029

    
3030
    nb_input_files++;
3031

    
3032
    video_channel = 0;
3033

    
3034
    av_freep(&video_codec_name);
3035
    av_freep(&audio_codec_name);
3036
    av_freep(&subtitle_codec_name);
3037
}
3038

    
3039
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3040
                                         int *has_subtitle_ptr)
3041
{
3042
    int has_video, has_audio, has_subtitle, i, j;
3043
    AVFormatContext *ic;
3044

    
3045
    has_video = 0;
3046
    has_audio = 0;
3047
    has_subtitle = 0;
3048
    for(j=0;j<nb_input_files;j++) {
3049
        ic = input_files[j];
3050
        for(i=0;i<ic->nb_streams;i++) {
3051
            AVCodecContext *enc = ic->streams[i]->codec;
3052
            switch(enc->codec_type) {
3053
            case CODEC_TYPE_AUDIO:
3054
                has_audio = 1;
3055
                break;
3056
            case CODEC_TYPE_VIDEO:
3057
                has_video = 1;
3058
                break;
3059
            case CODEC_TYPE_SUBTITLE:
3060
                has_subtitle = 1;
3061
                break;
3062
            case CODEC_TYPE_DATA:
3063
            case CODEC_TYPE_ATTACHMENT:
3064
            case CODEC_TYPE_UNKNOWN:
3065
                break;
3066
            default:
3067
                abort();
3068
            }
3069
        }
3070
    }
3071
    *has_video_ptr = has_video;
3072
    *has_audio_ptr = has_audio;
3073
    *has_subtitle_ptr = has_subtitle;
3074
}
3075

    
3076
static void new_video_stream(AVFormatContext *oc)
3077
{
3078
    AVStream *st;
3079
    AVCodecContext *video_enc;
3080
    enum CodecID codec_id;
3081

    
3082
    st = av_new_stream(oc, oc->nb_streams);
3083
    if (!st) {
3084
        fprintf(stderr, "Could not alloc stream\n");
3085
        av_exit(1);
3086
    }
3087
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3088
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3089
    video_bitstream_filters= NULL;
3090

    
3091
    avcodec_thread_init(st->codec, thread_count);
3092

    
3093
    video_enc = st->codec;
3094

    
3095
    if(video_codec_tag)
3096
        video_enc->codec_tag= video_codec_tag;
3097

    
3098
    if(   (video_global_header&1)
3099
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3100
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3101
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3102
    }
3103
    if(video_global_header&2){
3104
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3105
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3106
    }
3107

    
3108
    if (video_stream_copy) {
3109
        st->stream_copy = 1;
3110
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3111
        video_enc->sample_aspect_ratio =
3112
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3113
    } else {
3114
        const char *p;
3115
        int i;
3116
        AVCodec *codec;
3117
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3118

    
3119
        if (video_codec_name) {
3120
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3121
            codec = avcodec_find_encoder_by_name(video_codec_name);
3122
            output_codecs[nb_ocodecs] = codec;
3123
        } else {
3124
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3125
            codec = avcodec_find_encoder(codec_id);
3126
        }
3127

    
3128
        video_enc->codec_id = codec_id;
3129

    
3130
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3131

    
3132
        if (codec && codec->supported_framerates && !force_fps)
3133
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3134
        video_enc->time_base.den = fps.num;
3135
        video_enc->time_base.num = fps.den;
3136

    
3137
        video_enc->width = frame_width + frame_padright + frame_padleft;
3138
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3139
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3140
        video_enc->pix_fmt = frame_pix_fmt;
3141
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3142

    
3143
        if(codec && codec->pix_fmts){
3144
            const enum PixelFormat *p= codec->pix_fmts;
3145
            for(; *p!=-1; p++){
3146
                if(*p == video_enc->pix_fmt)
3147
                    break;
3148
            }
3149
            if(*p == -1)
3150
                video_enc->pix_fmt = codec->pix_fmts[0];
3151
        }
3152

    
3153
        if (intra_only)
3154
            video_enc->gop_size = 0;
3155
        if (video_qscale || same_quality) {
3156
            video_enc->flags |= CODEC_FLAG_QSCALE;
3157
            video_enc->global_quality=
3158
                st->quality = FF_QP2LAMBDA * video_qscale;
3159
        }
3160

    
3161
        if(intra_matrix)
3162
            video_enc->intra_matrix = intra_matrix;
3163
        if(inter_matrix)
3164
            video_enc->inter_matrix = inter_matrix;
3165

    
3166
        p= video_rc_override_string;
3167
        for(i=0; p; i++){
3168
            int start, end, q;
3169
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3170
            if(e!=3){
3171
                fprintf(stderr, "error parsing rc_override\n");
3172
                av_exit(1);
3173
            }
3174
            video_enc->rc_override=
3175
                av_realloc(video_enc->rc_override,
3176
                           sizeof(RcOverride)*(i+1));
3177
            video_enc->rc_override[i].start_frame= start;
3178
            video_enc->rc_override[i].end_frame  = end;
3179
            if(q>0){
3180
                video_enc->rc_override[i].qscale= q;
3181
                video_enc->rc_override[i].quality_factor= 1.0;
3182
            }
3183
            else{
3184
                video_enc->rc_override[i].qscale= 0;
3185
                video_enc->rc_override[i].quality_factor= -q/100.0;
3186
            }
3187
            p= strchr(p, '/');
3188
            if(p) p++;
3189
        }
3190
        video_enc->rc_override_count=i;
3191
        if (!video_enc->rc_initial_buffer_occupancy)
3192
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3193
        video_enc->me_threshold= me_threshold;
3194
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3195

    
3196
        if (do_psnr)
3197
            video_enc->flags|= CODEC_FLAG_PSNR;
3198

    
3199
        /* two pass mode */
3200
        if (do_pass) {
3201
            if (do_pass == 1) {
3202
                video_enc->flags |= CODEC_FLAG_PASS1;
3203
            } else {
3204
                video_enc->flags |= CODEC_FLAG_PASS2;
3205
            }
3206
        }
3207
    }
3208
    nb_ocodecs++;
3209
    if (video_language) {
3210
        av_metadata_set(&st->metadata, "language", video_language);
3211
        av_freep(&video_language);
3212
    }
3213

    
3214
    /* reset some key parameters */
3215
    video_disable = 0;
3216
    av_freep(&video_codec_name);
3217
    video_stream_copy = 0;
3218
}
3219

    
3220
static void new_audio_stream(AVFormatContext *oc)
3221
{
3222
    AVStream *st;
3223
    AVCodecContext *audio_enc;
3224
    enum CodecID codec_id;
3225

    
3226
    st = av_new_stream(oc, oc->nb_streams);
3227
    if (!st) {
3228
        fprintf(stderr, "Could not alloc stream\n");
3229
        av_exit(1);
3230
    }
3231
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3232

    
3233
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3234
    audio_bitstream_filters= NULL;
3235

    
3236
    avcodec_thread_init(st->codec, thread_count);
3237

    
3238
    audio_enc = st->codec;
3239
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3240

    
3241
    if(audio_codec_tag)
3242
        audio_enc->codec_tag= audio_codec_tag;
3243

    
3244
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3245
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3246
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3247
    }
3248
    if (audio_stream_copy) {
3249
        st->stream_copy = 1;
3250
        audio_enc->channels = audio_channels;
3251
    } else {
3252
        AVCodec *codec;
3253

    
3254
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3255

    
3256
        if (audio_codec_name) {
3257
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3258
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3259
            output_codecs[nb_ocodecs] = codec;
3260
        } else {
3261
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3262
            codec = avcodec_find_encoder(codec_id);
3263
        }
3264
        audio_enc->codec_id = codec_id;
3265

    
3266
        if (audio_qscale > QSCALE_NONE) {
3267
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3268
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3269
        }
3270
        audio_enc->channels = audio_channels;
3271
        audio_enc->sample_fmt = audio_sample_fmt;
3272
        audio_enc->channel_layout = channel_layout;
3273
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3274
            audio_enc->channel_layout = 0;
3275

    
3276
        if(codec && codec->sample_fmts){
3277
            const enum SampleFormat *p= codec->sample_fmts;
3278
            for(; *p!=-1; p++){
3279
                if(*p == audio_enc->sample_fmt)
3280
                    break;
3281
            }
3282
            if(*p == -1)
3283
                audio_enc->sample_fmt = codec->sample_fmts[0];
3284
        }
3285
    }
3286
    nb_ocodecs++;
3287
    audio_enc->sample_rate = audio_sample_rate;
3288
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3289
    if (audio_language) {
3290
        av_metadata_set(&st->metadata, "language", audio_language);
3291
        av_freep(&audio_language);
3292
    }
3293

    
3294
    /* reset some key parameters */
3295
    audio_disable = 0;
3296
    av_freep(&audio_codec_name);
3297
    audio_stream_copy = 0;
3298
}
3299

    
3300
static void new_subtitle_stream(AVFormatContext *oc)
3301
{
3302
    AVStream *st;
3303
    AVCodecContext *subtitle_enc;
3304

    
3305
    st = av_new_stream(oc, oc->nb_streams);
3306
    if (!st) {
3307
        fprintf(stderr, "Could not alloc stream\n");
3308
        av_exit(1);
3309
    }
3310
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3311

    
3312
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3313
    subtitle_bitstream_filters= NULL;
3314

    
3315
    subtitle_enc = st->codec;
3316
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3317

    
3318
    if(subtitle_codec_tag)
3319
        subtitle_enc->codec_tag= subtitle_codec_tag;
3320

    
3321
    if (subtitle_stream_copy) {
3322
        st->stream_copy = 1;
3323
    } else {
3324
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3325
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3326
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3327
    }
3328
    nb_ocodecs++;
3329

    
3330
    if (subtitle_language) {
3331
        av_metadata_set(&st->metadata, "language", subtitle_language);
3332
        av_freep(&subtitle_language);
3333
    }
3334

    
3335
    subtitle_disable = 0;
3336
    av_freep(&subtitle_codec_name);
3337
    subtitle_stream_copy = 0;
3338
}
3339

    
3340
static void opt_new_audio_stream(void)
3341
{
3342
    AVFormatContext *oc;
3343
    if (nb_output_files <= 0) {
3344
        fprintf(stderr, "At least one output file must be specified\n");
3345
        av_exit(1);
3346
    }
3347
    oc = output_files[nb_output_files - 1];
3348
    new_audio_stream(oc);
3349
}
3350

    
3351
static void opt_new_video_stream(void)
3352
{
3353
    AVFormatContext *oc;
3354
    if (nb_output_files <= 0) {
3355
        fprintf(stderr, "At least one output file must be specified\n");
3356
        av_exit(1);
3357
    }
3358
    oc = output_files[nb_output_files - 1];
3359
    new_video_stream(oc);
3360
}
3361

    
3362
static void opt_new_subtitle_stream(void)
3363
{
3364
    AVFormatContext *oc;
3365
    if (nb_output_files <= 0) {
3366
        fprintf(stderr, "At least one output file must be specified\n");
3367
        av_exit(1);
3368
    }
3369
    oc = output_files[nb_output_files - 1];
3370
    new_subtitle_stream(oc);
3371
}
3372

    
3373
static void opt_output_file(const char *filename)
3374
{
3375
    AVFormatContext *oc;
3376
    int use_video, use_audio, use_subtitle;
3377
    int input_has_video, input_has_audio, input_has_subtitle;
3378
    AVFormatParameters params, *ap = &params;
3379
    AVOutputFormat *file_oformat;
3380

    
3381
    if (!strcmp(filename, "-"))
3382
        filename = "pipe:";
3383

    
3384
    oc = avformat_alloc_context();
3385
    if (!oc) {
3386
        print_error(filename, AVERROR(ENOMEM));
3387
        av_exit(1);
3388
    }
3389

    
3390
    if (last_asked_format) {
3391
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3392
        if (!file_oformat) {
3393
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3394
            av_exit(1);
3395
        }
3396
        last_asked_format = NULL;
3397
    } else {
3398
        file_oformat = av_guess_format(NULL, filename, NULL);
3399
        if (!file_oformat) {
3400
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3401
                    filename);
3402
            av_exit(1);
3403
        }
3404
    }
3405

    
3406
    oc->oformat = file_oformat;
3407
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3408

    
3409
    if (!strcmp(file_oformat->name, "ffm") &&
3410
        av_strstart(filename, "http:", NULL)) {
3411
        /* special case for files sent to ffserver: we get the stream
3412
           parameters from ffserver */
3413
        int err = read_ffserver_streams(oc, filename);
3414
        if (err < 0) {
3415
            print_error(filename, err);
3416
            av_exit(1);
3417
        }
3418
    } else {
3419
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3420
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3421
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3422

    
3423
        /* disable if no corresponding type found and at least one
3424
           input file */
3425
        if (nb_input_files > 0) {
3426
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3427
                                         &input_has_subtitle);
3428
            if (!input_has_video)
3429
                use_video = 0;
3430
            if (!input_has_audio)
3431
                use_audio = 0;
3432
            if (!input_has_subtitle)
3433
                use_subtitle = 0;
3434
        }
3435

    
3436
        /* manual disable */
3437
        if (audio_disable) {
3438
            use_audio = 0;
3439
        }
3440
        if (video_disable) {
3441
            use_video = 0;
3442
        }
3443
        if (subtitle_disable) {
3444
            use_subtitle = 0;
3445
        }
3446

    
3447
        if (use_video) {
3448
            new_video_stream(oc);
3449
        }
3450

    
3451
        if (use_audio) {
3452
            new_audio_stream(oc);
3453
        }
3454

    
3455
        if (use_subtitle) {
3456
            new_subtitle_stream(oc);
3457
        }
3458

    
3459
        oc->timestamp = rec_timestamp;
3460

    
3461
        for(; metadata_count>0; metadata_count--){
3462
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3463
                                           metadata[metadata_count-1].value);
3464
        }
3465
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3466
    }
3467

    
3468
    output_files[nb_output_files++] = oc;
3469

    
3470
    /* check filename in case of an image number is expected */
3471
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3472
        if (!av_filename_number_test(oc->filename)) {
3473
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3474
            av_exit(1);
3475
        }
3476
    }
3477

    
3478
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3479
        /* test if it already exists to avoid loosing precious files */
3480
        if (!file_overwrite &&
3481
            (strchr(filename, ':') == NULL ||
3482
             filename[1] == ':' ||
3483
             av_strstart(filename, "file:", NULL))) {
3484
            if (url_exist(filename)) {
3485
                if (!using_stdin) {
3486
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3487
                    fflush(stderr);
3488
                    if (!read_yesno()) {
3489
                        fprintf(stderr, "Not overwriting - exiting\n");
3490
                        av_exit(1);
3491
                    }
3492
                }
3493
                else {
3494
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3495
                    av_exit(1);
3496
                }
3497
            }
3498
        }
3499

    
3500
        /* open the file */
3501
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3502
            fprintf(stderr, "Could not open '%s'\n", filename);
3503
            av_exit(1);
3504
        }
3505
    }
3506

    
3507
    memset(ap, 0, sizeof(*ap));
3508
    if (av_set_parameters(oc, ap) < 0) {
3509
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3510
                oc->filename);
3511
        av_exit(1);
3512
    }
3513

    
3514
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3515
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3516
    oc->loop_output = loop_output;
3517
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3518

    
3519
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3520
}
3521

    
3522
/* same option as mencoder */
3523
static void opt_pass(const char *pass_str)
3524
{
3525
    int pass;
3526
    pass = atoi(pass_str);
3527
    if (pass != 1 && pass != 2) {
3528
        fprintf(stderr, "pass number can be only 1 or 2\n");
3529
        av_exit(1);
3530
    }
3531
    do_pass = pass;
3532
}
3533

    
3534
static int64_t getutime(void)
3535
{
3536
#if HAVE_GETRUSAGE
3537
    struct rusage rusage;
3538

    
3539
    getrusage(RUSAGE_SELF, &rusage);
3540
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3541
#elif HAVE_GETPROCESSTIMES
3542
    HANDLE proc;
3543
    FILETIME c, e, k, u;
3544
    proc = GetCurrentProcess();
3545
    GetProcessTimes(proc, &c, &e, &k, &u);
3546
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3547
#else
3548
    return av_gettime();
3549
#endif
3550
}
3551

    
3552
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3553
{
3554
    int i;
3555
    const char *p = str;
3556
    for(i = 0;; i++) {
3557
        dest[i] = atoi(p);
3558
        if(i == 63)
3559
            break;
3560
        p = strchr(p, ',');
3561
        if(!p) {
3562
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3563
            av_exit(1);
3564
        }
3565
        p++;
3566
    }
3567
}
3568

    
3569
static void opt_inter_matrix(const char *arg)
3570
{
3571
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3572
    parse_matrix_coeffs(inter_matrix, arg);
3573
}
3574

    
3575
static void opt_intra_matrix(const char *arg)
3576
{
3577
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3578
    parse_matrix_coeffs(intra_matrix, arg);
3579
}
3580

    
3581
/**
3582
 * Trivial log callback.
3583
 * Only suitable for show_help and similar since it lacks prefix handling.
3584
 */
3585
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3586
{
3587
    vfprintf(stdout, fmt, vl);
3588
}
3589

    
3590
static void show_usage(void)
3591
{
3592
    printf("Hyper fast Audio and Video encoder\n");
3593
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3594
    printf("\n");
3595
}
3596

    
3597
static void show_help(void)
3598
{
3599
    av_log_set_callback(log_callback_help);
3600
    show_usage();
3601
    show_help_options(options, "Main options:\n",
3602
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3603
    show_help_options(options, "\nAdvanced options:\n",
3604
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3605
                      OPT_EXPERT);
3606
    show_help_options(options, "\nVideo options:\n",
3607
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3608
                      OPT_VIDEO);
3609
    show_help_options(options, "\nAdvanced Video options:\n",
3610
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3611
                      OPT_VIDEO | OPT_EXPERT);
3612
    show_help_options(options, "\nAudio options:\n",
3613
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3614
                      OPT_AUDIO);
3615
    show_help_options(options, "\nAdvanced Audio options:\n",
3616
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3617
                      OPT_AUDIO | OPT_EXPERT);
3618
    show_help_options(options, "\nSubtitle options:\n",
3619
                      OPT_SUBTITLE | OPT_GRAB,
3620
                      OPT_SUBTITLE);
3621
    show_help_options(options, "\nAudio/Video grab options:\n",
3622
                      OPT_GRAB,
3623
                      OPT_GRAB);
3624
    printf("\n");
3625
    av_opt_show(avcodec_opts[0], NULL);
3626
    printf("\n");
3627
    av_opt_show(avformat_opts, NULL);
3628
    printf("\n");
3629
    av_opt_show(sws_opts, NULL);
3630
}
3631

    
3632
static void opt_target(const char *arg)
3633
{
3634
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3635
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3636

    
3637
    if(!strncmp(arg, "pal-", 4)) {
3638
        norm = PAL;
3639
        arg += 4;
3640
    } else if(!strncmp(arg, "ntsc-", 5)) {
3641
        norm = NTSC;
3642
        arg += 5;
3643
    } else if(!strncmp(arg, "film-", 5)) {
3644
        norm = FILM;
3645
        arg += 5;
3646
    } else {
3647
        int fr;
3648
        /* Calculate FR via float to avoid int overflow */
3649
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3650
        if(fr == 25000) {
3651
            norm = PAL;
3652
        } else if((fr == 29970) || (fr == 23976)) {
3653
            norm = NTSC;
3654
        } else {
3655
            /* Try to determine PAL/NTSC by peeking in the input files */
3656
            if(nb_input_files) {
3657
                int i, j;
3658
                for(j = 0; j < nb_input_files; j++) {
3659
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3660
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3661
                        if(c->codec_type != CODEC_TYPE_VIDEO)
3662
                            continue;
3663
                        fr = c->time_base.den * 1000 / c->time_base.num;
3664
                        if(fr == 25000) {
3665
                            norm = PAL;
3666
                            break;
3667
                        } else if((fr == 29970) || (fr == 23976)) {
3668
                            norm = NTSC;
3669
                            break;
3670
                        }
3671
                    }
3672
                    if(norm != UNKNOWN)
3673
                        break;
3674
                }
3675
            }
3676
        }
3677
        if(verbose && norm != UNKNOWN)
3678
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3679
    }
3680

    
3681
    if(norm == UNKNOWN) {
3682
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3683
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3684
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3685
        av_exit(1);
3686
    }
3687

    
3688
    if(!strcmp(arg, "vcd")) {
3689

    
3690
        opt_video_codec("mpeg1video");
3691
        opt_audio_codec("mp2");
3692
        opt_format("vcd");
3693

    
3694
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3695
        opt_frame_rate(NULL, frame_rates[norm]);
3696
        opt_default("g", norm == PAL ? "15" : "18");
3697

    
3698
        opt_default("b", "1150000");
3699
        opt_default("maxrate", "1150000");
3700
        opt_default("minrate", "1150000");
3701
        opt_default("bufsize", "327680"); // 40*1024*8;
3702

    
3703
        opt_default("ab", "224000");
3704
        audio_sample_rate = 44100;
3705
        audio_channels = 2;
3706

    
3707
        opt_default("packetsize", "2324");
3708
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3709

    
3710
        /* We have to offset the PTS, so that it is consistent with the SCR.
3711
           SCR starts at 36000, but the first two packs contain only padding
3712
           and the first pack from the other stream, respectively, may also have
3713
           been written before.
3714
           So the real data starts at SCR 36000+3*1200. */
3715
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3716
    } else if(!strcmp(arg, "svcd")) {
3717

    
3718
        opt_video_codec("mpeg2video");
3719
        opt_audio_codec("mp2");
3720
        opt_format("svcd");
3721

    
3722
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3723
        opt_frame_rate(NULL, frame_rates[norm]);
3724
        opt_default("g", norm == PAL ? "15" : "18");
3725

    
3726
        opt_default("b", "2040000");
3727
        opt_default("maxrate", "2516000");
3728
        opt_default("minrate", "0"); //1145000;
3729
        opt_default("bufsize", "1835008"); //224*1024*8;
3730
        opt_default("flags", "+scan_offset");
3731

    
3732

    
3733
        opt_default("ab", "224000");
3734
        audio_sample_rate = 44100;
3735

    
3736
        opt_default("packetsize", "2324");
3737

    
3738
    } else if(!strcmp(arg, "dvd")) {
3739

    
3740
        opt_video_codec("mpeg2video");
3741
        opt_audio_codec("ac3");
3742
        opt_format("dvd");
3743

    
3744
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3745
        opt_frame_rate(NULL, frame_rates[norm]);
3746
        opt_default("g", norm == PAL ? "15" : "18");
3747

    
3748
        opt_default("b", "6000000");
3749
        opt_default("maxrate", "9000000");
3750
        opt_default("minrate", "0"); //1500000;
3751
        opt_default("bufsize", "1835008"); //224*1024*8;
3752

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

    
3756
        opt_default("ab", "448000");
3757
        audio_sample_rate = 48000;
3758

    
3759
    } else if(!strncmp(arg, "dv", 2)) {
3760

    
3761
        opt_format("dv");
3762

    
3763
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3764
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3765
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3766
        opt_frame_rate(NULL, frame_rates[norm]);
3767

    
3768
        audio_sample_rate = 48000;
3769
        audio_channels = 2;
3770

    
3771
    } else {
3772
        fprintf(stderr, "Unknown target: %s\n", arg);
3773
        av_exit(1);
3774
    }
3775
}
3776

    
3777
static void opt_vstats_file (const char *arg)
3778
{
3779
    av_free (vstats_filename);
3780
    vstats_filename=av_strdup (arg);
3781
}
3782

    
3783
static void opt_vstats (void)
3784
{
3785
    char filename[40];
3786
    time_t today2 = time(NULL);
3787
    struct tm *today = localtime(&today2);
3788

    
3789
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3790
             today->tm_sec);
3791
    opt_vstats_file(filename);
3792
}
3793

    
3794
static int opt_bsf(const char *opt, const char *arg)
3795
{
3796
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3797
    AVBitStreamFilterContext **bsfp;
3798

    
3799
    if(!bsfc){
3800
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3801
        av_exit(1);
3802
    }
3803

    
3804
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3805
          *opt == 'a' ? &audio_bitstream_filters :
3806
                        &subtitle_bitstream_filters;
3807
    while(*bsfp)
3808
        bsfp= &(*bsfp)->next;
3809

    
3810
    *bsfp= bsfc;
3811

    
3812
    return 0;
3813
}
3814

    
3815
static int opt_preset(const char *opt, const char *arg)
3816
{
3817
    FILE *f=NULL;
3818
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3819
    int i;
3820
    const char *base[2]= { getenv("HOME"),
3821
                           FFMPEG_DATADIR,
3822
                         };
3823

    
3824
    if (*opt != 'f') {
3825
        for(i=!base[0]; i<2 && !f; i++){
3826
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3827
            f= fopen(filename, "r");
3828
            if(!f){
3829
                char *codec_name= *opt == 'v' ? video_codec_name :
3830
                                  *opt == 'a' ? audio_codec_name :
3831
                                                subtitle_codec_name;
3832
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3833
                f= fopen(filename, "r");
3834
            }
3835
        }
3836
    } else {
3837
        av_strlcpy(filename, arg, sizeof(filename));
3838
        f= fopen(filename, "r");
3839
    }
3840

    
3841
    if(!f){
3842
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3843
        av_exit(1);
3844
    }
3845

    
3846
    while(!feof(f)){
3847
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3848
        if(line[0] == '#' && !e)
3849
            continue;
3850
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3851
        if(e){
3852
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3853
            av_exit(1);
3854
        }
3855
        if(!strcmp(tmp, "acodec")){
3856
            opt_audio_codec(tmp2);
3857
        }else if(!strcmp(tmp, "vcodec")){
3858
            opt_video_codec(tmp2);
3859
        }else if(!strcmp(tmp, "scodec")){
3860
            opt_subtitle_codec(tmp2);
3861
        }else if(opt_default(tmp, tmp2) < 0){
3862
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3863
            av_exit(1);
3864
        }
3865
    }
3866

    
3867
    fclose(f);
3868

    
3869
    return 0;
3870
}
3871

    
3872
static const OptionDef options[] = {
3873
    /* main options */
3874
#include "cmdutils_common_opts.h"
3875
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3876
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3877
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3878
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3879
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3880
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3881
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3882
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3883
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3884
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3885
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3886
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3887
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3888
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3889
      "add timings for benchmarking" },
3890
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
3891
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3892
      "dump each input packet" },
3893
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3894
      "when dumping packets, also dump the payload" },
3895
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3896
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3897
    { "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)", "" },
3898
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3899
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3900
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3901
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3902
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3903
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3904
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3905
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3906
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3907
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3908
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3909
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3910
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3911

    
3912
    /* video options */
3913
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3914
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3915
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3916
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3917
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3918
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3919
    { "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" },
3920
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3921
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3922
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3923
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3924
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3925
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3926
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3927
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3928
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3929
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3930
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3931
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3932
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3933
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3934
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3935
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3936
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3937
      "use same video quality as source (implies VBR)" },
3938
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3939
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3940
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3941
      "deinterlace pictures" },
3942
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3943
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3944
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3945
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3946
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3947
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3948
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3949
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3950
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3951
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
3952
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3953
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3954

    
3955
    /* audio options */
3956
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3957
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3958
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3959
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3960
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3961
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3962
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3963
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3964
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3965
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3966
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3967
    { "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" },
3968

    
3969
    /* subtitle options */
3970
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3971
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3972
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3973
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3974
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3975

    
3976
    /* grab options */
3977
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3978
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3979
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3980

    
3981
    /* muxer options */
3982
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3983
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3984

    
3985
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3986
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3987
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3988

    
3989
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3990
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3991
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3992
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3993

    
3994
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3995
    { NULL, },
3996
};
3997

    
3998
int main(int argc, char **argv)
3999
{
4000
    int i;
4001
    int64_t ti;
4002

    
4003
    avcodec_register_all();
4004
    avdevice_register_all();
4005
    av_register_all();
4006

    
4007
#if HAVE_ISATTY
4008
    if(isatty(STDIN_FILENO))
4009
        url_set_interrupt_cb(decode_interrupt_cb);
4010
#endif
4011

    
4012
    for(i=0; i<CODEC_TYPE_NB; i++){
4013
        avcodec_opts[i]= avcodec_alloc_context2(i);
4014
    }
4015
    avformat_opts = avformat_alloc_context();
4016
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4017

    
4018
    show_banner();
4019

    
4020
    /* parse options */
4021
    parse_options(argc, argv, options, opt_output_file);
4022

    
4023
    if(nb_output_files <= 0 && nb_input_files == 0) {
4024
        show_usage();
4025
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4026
        av_exit(1);
4027
    }
4028

    
4029
    /* file converter / grab */
4030
    if (nb_output_files <= 0) {
4031
        fprintf(stderr, "At least one output file must be specified\n");
4032
        av_exit(1);
4033
    }
4034

    
4035
    if (nb_input_files == 0) {
4036
        fprintf(stderr, "At least one input file must be specified\n");
4037
        av_exit(1);
4038
    }
4039

    
4040
    ti = getutime();
4041
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4042
                  stream_maps, nb_stream_maps) < 0)
4043
        av_exit(1);
4044
    ti = getutime() - ti;
4045
    if (do_benchmark) {
4046
        printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4047
    }
4048

    
4049
    return av_exit(0);
4050
}