Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ a15fdd7c

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/time.h>
48
#include <sys/resource.h>
49
#elif HAVE_GETPROCESSTIMES
50
#include <windows.h>
51
#endif
52
#if HAVE_GETPROCESSMEMORYINFO
53
#include <windows.h>
54
#include <psapi.h>
55
#endif
56

    
57
#if HAVE_SYS_SELECT_H
58
#include <sys/select.h>
59
#endif
60

    
61
#if HAVE_TERMIOS_H
62
#include <fcntl.h>
63
#include <sys/ioctl.h>
64
#include <sys/time.h>
65
#include <termios.h>
66
#elif HAVE_CONIO_H
67
#include <conio.h>
68
#endif
69
#undef time //needed because HAVE_AV_CONFIG_H is defined on top
70
#include <time.h>
71

    
72
#include "cmdutils.h"
73

    
74
#undef NDEBUG
75
#include <assert.h>
76

    
77
#undef exit
78

    
79
const char program_name[] = "FFmpeg";
80
const int program_birth_year = 2000;
81

    
82
/* select an input stream for an output stream */
83
typedef struct AVStreamMap {
84
    int file_index;
85
    int stream_index;
86
    int sync_file_index;
87
    int sync_stream_index;
88
} AVStreamMap;
89

    
90
/** select an input file for an output file */
91
typedef struct AVMetaDataMap {
92
    int out_file;
93
    int in_file;
94
} AVMetaDataMap;
95

    
96
static const OptionDef options[];
97

    
98
#define MAX_FILES 100
99

    
100
static const char *last_asked_format = NULL;
101
static AVFormatContext *input_files[MAX_FILES];
102
static int64_t input_files_ts_offset[MAX_FILES];
103
static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
104
static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
105
static int nb_input_files = 0;
106
static int nb_icodecs;
107

    
108
static AVFormatContext *output_files[MAX_FILES];
109
static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
110
static int nb_output_files = 0;
111
static int nb_ocodecs;
112

    
113
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
114
static int nb_stream_maps;
115

    
116
static AVMetaDataMap meta_data_maps[MAX_FILES];
117
static int nb_meta_data_maps;
118

    
119
static int frame_width  = 0;
120
static int frame_height = 0;
121
static float frame_aspect_ratio = 0;
122
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
123
static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
124
static int frame_padtop  = 0;
125
static int frame_padbottom = 0;
126
static int frame_padleft  = 0;
127
static int frame_padright = 0;
128
static int padcolor[3] = {16,128,128}; /* default to black */
129
static int frame_topBand  = 0;
130
static int frame_bottomBand = 0;
131
static int frame_leftBand  = 0;
132
static int frame_rightBand = 0;
133
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
134
static AVRational frame_rate;
135
static float video_qscale = 0;
136
static uint16_t *intra_matrix = NULL;
137
static uint16_t *inter_matrix = NULL;
138
static const char *video_rc_override_string=NULL;
139
static int video_disable = 0;
140
static int video_discard = 0;
141
static char *video_codec_name = NULL;
142
static int video_codec_tag = 0;
143
static char *video_language = NULL;
144
static int same_quality = 0;
145
static int do_deinterlace = 0;
146
static int top_field_first = -1;
147
static int me_threshold = 0;
148
static int intra_dc_precision = 8;
149
static int loop_input = 0;
150
static int loop_output = AVFMT_NOOUTPUTLOOP;
151
static int qp_hist = 0;
152

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

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

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

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

    
199
static int rate_emu = 0;
200

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

    
204
static int audio_volume = 256;
205

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

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

    
223
static unsigned int sws_flags = SWS_BICUBIC;
224

    
225
static int64_t timer_start;
226

    
227
static uint8_t *audio_buf;
228
static uint8_t *audio_out;
229
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
230

    
231
static short *samples;
232

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

    
238
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
239

    
240
struct AVInputStream;
241

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

    
262
    /* full frame size of first frame */
263
    int original_height;
264
    int original_width;
265

    
266
    /* cropping area sizes */
267
    int video_crop;
268
    int topBand;
269
    int bottomBand;
270
    int leftBand;
271
    int rightBand;
272

    
273
    /* cropping area of first frame */
274
    int original_topBand;
275
    int original_bottomBand;
276
    int original_leftBand;
277
    int original_rightBand;
278

    
279
    /* padding area sizes */
280
    int video_pad;
281
    int padtop;
282
    int padbottom;
283
    int padleft;
284
    int padright;
285

    
286
    /* audio only */
287
    int audio_resample;
288
    ReSampleContext *resample; /* for audio resampling */
289
    int reformat_pair;
290
    AVAudioConvert *reformat_ctx;
291
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
292
    FILE *logfile;
293
} AVOutputStream;
294

    
295
typedef struct AVInputStream {
296
    int file_index;
297
    int index;
298
    AVStream *st;
299
    int discard;             /* true if stream data should be discarded */
300
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
301
    int64_t sample_index;      /* current sample */
302

    
303
    int64_t       start;     /* time when read started */
304
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
305
                                is not defined */
306
    int64_t       pts;       /* current pts */
307
    int is_start;            /* is 1 at the start and after a discontinuity */
308
    int showed_multi_packet_warning;
309
    int is_past_recording_time;
310
} AVInputStream;
311

    
312
typedef struct AVInputFile {
313
    int eof_reached;      /* true if eof reached */
314
    int ist_index;        /* index of first stream in ist_table */
315
    int buffer_size;      /* current total buffer size */
316
    int nb_streams;       /* nb streams we are aware of */
317
} AVInputFile;
318

    
319
#if HAVE_TERMIOS_H
320

    
321
/* init terminal so that we can grab keys */
322
static struct termios oldtty;
323
#endif
324

    
325
static void term_exit(void)
326
{
327
#if HAVE_TERMIOS_H
328
    tcsetattr (0, TCSANOW, &oldtty);
329
#endif
330
}
331

    
332
static volatile int received_sigterm = 0;
333

    
334
static void
335
sigterm_handler(int sig)
336
{
337
    received_sigterm = sig;
338
    term_exit();
339
}
340

    
341
static void term_init(void)
342
{
343
#if HAVE_TERMIOS_H
344
    struct termios tty;
345

    
346
    tcgetattr (0, &tty);
347
    oldtty = tty;
348

    
349
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
350
                          |INLCR|IGNCR|ICRNL|IXON);
351
    tty.c_oflag |= OPOST;
352
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
353
    tty.c_cflag &= ~(CSIZE|PARENB);
354
    tty.c_cflag |= CS8;
355
    tty.c_cc[VMIN] = 1;
356
    tty.c_cc[VTIME] = 0;
357

    
358
    tcsetattr (0, TCSANOW, &tty);
359
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
360
#endif
361

    
362
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
363
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
364
#ifdef SIGXCPU
365
    signal(SIGXCPU, sigterm_handler);
366
#endif
367

    
368
    /*
369
    register a function to be called at normal program termination
370
    */
371
    atexit(term_exit);
372
#if CONFIG_BEOS_NETSERVER
373
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
374
#endif
375
}
376

    
377
/* read a key without blocking */
378
static int read_key(void)
379
{
380
#if HAVE_TERMIOS_H
381
    int n = 1;
382
    unsigned char ch;
383
#if !CONFIG_BEOS_NETSERVER
384
    struct timeval tv;
385
    fd_set rfds;
386

    
387
    FD_ZERO(&rfds);
388
    FD_SET(0, &rfds);
389
    tv.tv_sec = 0;
390
    tv.tv_usec = 0;
391
    n = select(1, &rfds, NULL, NULL, &tv);
392
#endif
393
    if (n > 0) {
394
        n = read(0, &ch, 1);
395
        if (n == 1)
396
            return ch;
397

    
398
        return n;
399
    }
400
#elif HAVE_CONIO_H
401
    if(kbhit())
402
        return(getch());
403
#endif
404
    return -1;
405
}
406

    
407
static int decode_interrupt_cb(void)
408
{
409
    return q_pressed || (q_pressed = read_key() == 'q');
410
}
411

    
412
static int av_exit(int ret)
413
{
414
    int i;
415

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

    
440
    av_free(intra_matrix);
441
    av_free(inter_matrix);
442

    
443
    if (vstats_file)
444
        fclose(vstats_file);
445
    av_free(vstats_filename);
446

    
447
    av_free(opt_names);
448

    
449
    av_free(video_codec_name);
450
    av_free(audio_codec_name);
451
    av_free(subtitle_codec_name);
452

    
453
    av_free(video_standard);
454

    
455
#if CONFIG_POWERPC_PERF
456
    void powerpc_display_perf_report(void);
457
    powerpc_display_perf_report();
458
#endif /* CONFIG_POWERPC_PERF */
459

    
460
    for (i=0;i<CODEC_TYPE_NB;i++)
461
        av_free(avcodec_opts[i]);
462
    av_free(avformat_opts);
463
    av_free(sws_opts);
464
    av_free(audio_buf);
465
    av_free(audio_out);
466
    allocated_audio_buf_size= allocated_audio_out_size= 0;
467
    av_free(samples);
468

    
469
    if (received_sigterm) {
470
        fprintf(stderr,
471
            "Received signal %d: terminating.\n",
472
            (int) received_sigterm);
473
        exit (255);
474
    }
475

    
476
    exit(ret); /* not all OS-es handle main() return value */
477
    return ret;
478
}
479

    
480
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
481
{
482
    int i, err;
483
    AVFormatContext *ic;
484
    int nopts = 0;
485

    
486
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
487
    if (err < 0)
488
        return err;
489
    /* copy stream format */
490
    s->nb_streams = ic->nb_streams;
491
    for(i=0;i<ic->nb_streams;i++) {
492
        AVStream *st;
493

    
494
        // FIXME: a more elegant solution is needed
495
        st = av_mallocz(sizeof(AVStream));
496
        memcpy(st, ic->streams[i], sizeof(AVStream));
497
        st->codec = avcodec_alloc_context();
498
        if (!st->codec) {
499
            print_error(filename, AVERROR(ENOMEM));
500
            av_exit(1);
501
        }
502
        memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
503
        s->streams[i] = st;
504

    
505
        if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
506
            st->stream_copy = 1;
507
        else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
508
            st->stream_copy = 1;
509

    
510
        if(!st->codec->thread_count)
511
            st->codec->thread_count = 1;
512
        if(st->codec->thread_count>1)
513
            avcodec_thread_init(st->codec, st->codec->thread_count);
514

    
515
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
516
            nopts = 1;
517
    }
518

    
519
    if (!nopts)
520
        s->timestamp = av_gettime();
521

    
522
    av_close_input_file(ic);
523
    return 0;
524
}
525

    
526
static double
527
get_sync_ipts(const AVOutputStream *ost)
528
{
529
    const AVInputStream *ist = ost->sync_ist;
530
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
531
}
532

    
533
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
534
    int ret;
535

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

    
555
        bsfc= bsfc->next;
556
    }
557

    
558
    ret= av_interleaved_write_frame(s, pkt);
559
    if(ret < 0){
560
        print_error("av_interleaved_write_frame()", ret);
561
        av_exit(1);
562
    }
563
}
564

    
565
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
566

    
567
static void do_audio_out(AVFormatContext *s,
568
                         AVOutputStream *ost,
569
                         AVInputStream *ist,
570
                         unsigned char *buf, int size)
571
{
572
    uint8_t *buftmp;
573
    int64_t audio_out_size, audio_buf_size;
574
    int64_t allocated_for_size= size;
575

    
576
    int size_out, frame_bytes, ret;
577
    AVCodecContext *enc= ost->st->codec;
578
    AVCodecContext *dec= ist->st->codec;
579
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
580
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
581
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
582

    
583
need_realloc:
584
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
585
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
586
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
587
    audio_buf_size*= osize*enc->channels;
588

    
589
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
590
    if(coded_bps > 8*osize)
591
        audio_out_size= audio_out_size * coded_bps / (8*osize);
592
    audio_out_size += FF_MIN_BUFFER_SIZE;
593

    
594
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
595
        fprintf(stderr, "Buffer sizes too large\n");
596
        av_exit(1);
597
    }
598

    
599
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
600
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
601
    if (!audio_buf || !audio_out){
602
        fprintf(stderr, "Out of memory in do_audio_out\n");
603
        av_exit(1);
604
    }
605

    
606
    if (enc->channels != dec->channels)
607
        ost->audio_resample = 1;
608

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

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

    
640
    if(audio_sync_method){
641
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
642
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
643
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
644
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
645

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

    
662
                    if(byte_delta > allocated_for_size - size){
663
                        allocated_for_size= byte_delta + (int64_t)size;
664
                        goto need_realloc;
665
                    }
666
                    ist->is_start=0;
667

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

    
688
    if (ost->audio_resample) {
689
        buftmp = audio_buf;
690
        size_out = audio_resample(ost->resample,
691
                                  (short *)buftmp, (short *)buf,
692
                                  size / (ist->st->codec->channels * isize));
693
        size_out = size_out * enc->channels * osize;
694
    } else {
695
        buftmp = buf;
696
        size_out = size;
697
    }
698

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

    
715
    /* now encode as many frames as possible */
716
    if (enc->frame_size > 1) {
717
        /* output resampled raw samples */
718
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
719
            fprintf(stderr, "av_fifo_realloc2() failed\n");
720
            av_exit(1);
721
        }
722
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
723

    
724
        frame_bytes = enc->frame_size * osize * enc->channels;
725

    
726
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
727
            AVPacket pkt;
728
            av_init_packet(&pkt);
729

    
730
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
731

    
732
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
733

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

    
749
            ost->sync_opts += enc->frame_size;
750
        }
751
    } else {
752
        AVPacket pkt;
753
        av_init_packet(&pkt);
754

    
755
        ost->sync_opts += size_out / (osize * enc->channels);
756

    
757
        /* output a pcm frame */
758
        /* determine the size of the coded buffer */
759
        size_out /= osize;
760
        if (coded_bps)
761
            size_out = size_out*coded_bps/8;
762

    
763
        if(size_out > audio_out_size){
764
            fprintf(stderr, "Internal error, buffer size too small\n");
765
            av_exit(1);
766
        }
767

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

    
786
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
787
{
788
    AVCodecContext *dec;
789
    AVPicture *picture2;
790
    AVPicture picture_tmp;
791
    uint8_t *buf = 0;
792

    
793
    dec = ist->st->codec;
794

    
795
    /* deinterlace : must be done before any resize */
796
    if (do_deinterlace) {
797
        int size;
798

    
799
        /* create temporary picture */
800
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
801
        buf = av_malloc(size);
802
        if (!buf)
803
            return;
804

    
805
        picture2 = &picture_tmp;
806
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
807

    
808
        if(avpicture_deinterlace(picture2, picture,
809
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
810
            /* if error, do not deinterlace */
811
            fprintf(stderr, "Deinterlacing failed\n");
812
            av_free(buf);
813
            buf = NULL;
814
            picture2 = picture;
815
        }
816
    } else {
817
        picture2 = picture;
818
    }
819

    
820
    if (picture != picture2)
821
        *picture = *picture2;
822
    *bufp = buf;
823
}
824

    
825
/* we begin to correct av delay at this threshold */
826
#define AV_DELAY_MAX 0.100
827

    
828
static void do_subtitle_out(AVFormatContext *s,
829
                            AVOutputStream *ost,
830
                            AVInputStream *ist,
831
                            AVSubtitle *sub,
832
                            int64_t pts)
833
{
834
    static uint8_t *subtitle_out = NULL;
835
    int subtitle_out_max_size = 1024 * 1024;
836
    int subtitle_out_size, nb, i;
837
    AVCodecContext *enc;
838
    AVPacket pkt;
839

    
840
    if (pts == AV_NOPTS_VALUE) {
841
        fprintf(stderr, "Subtitle packets must have a pts\n");
842
        if (exit_on_error)
843
            av_exit(1);
844
        return;
845
    }
846

    
847
    enc = ost->st->codec;
848

    
849
    if (!subtitle_out) {
850
        subtitle_out = av_malloc(subtitle_out_max_size);
851
    }
852

    
853
    /* Note: DVB subtitle need one packet to draw them and one other
854
       packet to clear them */
855
    /* XXX: signal it in the codec context ? */
856
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
857
        nb = 2;
858
    else
859
        nb = 1;
860

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

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

    
891
static int bit_buffer_size= 1024*256;
892
static uint8_t *bit_buffer= NULL;
893

    
894
static void do_video_out(AVFormatContext *s,
895
                         AVOutputStream *ost,
896
                         AVInputStream *ist,
897
                         AVFrame *in_picture,
898
                         int *frame_size)
899
{
900
    int nb_frames, i, ret;
901
    int64_t topBand, bottomBand, leftBand, rightBand;
902
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
903
    AVFrame picture_crop_temp, picture_pad_temp;
904
    AVCodecContext *enc, *dec;
905

    
906
    avcodec_get_frame_defaults(&picture_crop_temp);
907
    avcodec_get_frame_defaults(&picture_pad_temp);
908

    
909
    enc = ost->st->codec;
910
    dec = ist->st->codec;
911

    
912
    /* by default, we output a single frame */
913
    nb_frames = 1;
914

    
915
    *frame_size = 0;
916

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

    
943
    nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
944
    if (nb_frames <= 0)
945
        return;
946

    
947
    if (ost->video_crop) {
948
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
949
            fprintf(stderr, "error cropping picture\n");
950
            if (exit_on_error)
951
                av_exit(1);
952
            return;
953
        }
954
        formatted_picture = &picture_crop_temp;
955
    } else {
956
        formatted_picture = in_picture;
957
    }
958

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

    
975
    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
976
        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
977
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
978

    
979
        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));
980
        if(!ost->video_resample)
981
            av_exit(1);
982
    }
983

    
984
    if (ost->video_resample) {
985
        padding_src = NULL;
986
        final_picture = &ost->pict_tmp;
987
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
988
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
989
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
990

    
991
            /* keep bands proportional to the frame size */
992
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
993
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
994
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
995
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
996

    
997
            /* sanity check to ensure no bad band sizes sneak in */
998
            assert(topBand    <= INT_MAX && topBand    >= 0);
999
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
1000
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
1001
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
1002

    
1003
            ost->topBand    = topBand;
1004
            ost->bottomBand = bottomBand;
1005
            ost->leftBand   = leftBand;
1006
            ost->rightBand  = rightBand;
1007

    
1008
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
1009
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
1010
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1011

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

    
1032
    if (ost->video_pad) {
1033
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1034
                enc->height, enc->width, enc->pix_fmt,
1035
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1036
    }
1037

    
1038
    /* duplicates frame if needed */
1039
    for(i=0;i<nb_frames;i++) {
1040
        AVPacket pkt;
1041
        av_init_packet(&pkt);
1042
        pkt.stream_index= ost->index;
1043

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

    
1055
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1056
            enc->coded_frame = old_frame;
1057
        } else {
1058
            AVFrame big_picture;
1059

    
1060
            big_picture= *final_picture;
1061
            /* better than nothing: use input picture interlaced
1062
               settings */
1063
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1064
            if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1065
                if(top_field_first == -1)
1066
                    big_picture.top_field_first = in_picture->top_field_first;
1067
                else
1068
                    big_picture.top_field_first = top_field_first;
1069
            }
1070

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

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

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

    
1118
static double psnr(double d){
1119
    return -10.0*log(d)/log(10.0);
1120
}
1121

    
1122
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1123
                           int frame_size)
1124
{
1125
    AVCodecContext *enc;
1126
    int frame_number;
1127
    double ti1, bitrate, avg_bitrate;
1128

    
1129
    /* this is executed just the first time do_video_stats is called */
1130
    if (!vstats_file) {
1131
        vstats_file = fopen(vstats_filename, "w");
1132
        if (!vstats_file) {
1133
            perror("fopen");
1134
            av_exit(1);
1135
        }
1136
    }
1137

    
1138
    enc = ost->st->codec;
1139
    if (enc->codec_type == CODEC_TYPE_VIDEO) {
1140
        frame_number = ost->frame_number;
1141
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1142
        if (enc->flags&CODEC_FLAG_PSNR)
1143
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1144

    
1145
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1146
        /* compute pts value */
1147
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1148
        if (ti1 < 0.01)
1149
            ti1 = 0.01;
1150

    
1151
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1152
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1153
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1154
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1155
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1156
    }
1157
}
1158

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

    
1173
    if (!is_last_report) {
1174
        int64_t cur_time;
1175
        /* display the report every 0.5 seconds */
1176
        cur_time = av_gettime();
1177
        if (last_time == -1) {
1178
            last_time = cur_time;
1179
            return;
1180
        }
1181
        if ((cur_time - last_time) < 500000)
1182
            return;
1183
        last_time = cur_time;
1184
    }
1185

    
1186

    
1187
    oc = output_files[0];
1188

    
1189
    total_size = url_fsize(oc->pb);
1190
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1191
        total_size= url_ftell(oc->pb);
1192

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

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

    
1253
    if (verbose || is_last_report) {
1254
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1255

    
1256
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1257
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1258
            (double)total_size / 1024, ti1, bitrate);
1259

    
1260
        if (nb_frames_dup || nb_frames_drop)
1261
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1262
                  nb_frames_dup, nb_frames_drop);
1263

    
1264
        if (verbose >= 0)
1265
            fprintf(stderr, "%s    \r", buf);
1266

    
1267
        fflush(stderr);
1268
    }
1269

    
1270
    if (is_last_report && verbose >= 0){
1271
        int64_t raw= audio_size + video_size + extra_size;
1272
        fprintf(stderr, "\n");
1273
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1274
                video_size/1024.0,
1275
                audio_size/1024.0,
1276
                extra_size/1024.0,
1277
                100.0*(total_size - raw)/raw
1278
        );
1279
    }
1280
}
1281

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

    
1299
    if(ist->next_pts == AV_NOPTS_VALUE)
1300
        ist->next_pts= ist->pts;
1301

    
1302
    if (pkt == NULL) {
1303
        /* EOF handling */
1304
        av_init_packet(&avpkt);
1305
        avpkt.data = NULL;
1306
        avpkt.size = 0;
1307
        goto handle_eof;
1308
    } else {
1309
        avpkt = *pkt;
1310
    }
1311

    
1312
    if(pkt->dts != AV_NOPTS_VALUE)
1313
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1314

    
1315
    //while we have more to decode or while the decoder did output something on EOF
1316
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1317
        uint8_t *data_buf, *decoded_data_buf;
1318
        int data_size, decoded_data_size;
1319
    handle_eof:
1320
        ist->pts= ist->next_pts;
1321

    
1322
        if(avpkt.size && avpkt.size != pkt->size &&
1323
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1324
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1325
            ist->showed_multi_packet_warning=1;
1326
        }
1327

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

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

    
1417
        buffer_to_free = NULL;
1418
        if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1419
            pre_process_video_frame(ist, (AVPicture *)&picture,
1420
                                    &buffer_to_free);
1421
        }
1422

    
1423
        // preprocess audio (volume)
1424
        if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1425
            if (audio_volume != 256) {
1426
                short *volp;
1427
                volp = samples;
1428
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1429
                    int v = ((*volp) * audio_volume + 128) >> 8;
1430
                    if (v < -32768) v = -32768;
1431
                    if (v >  32767) v = 32767;
1432
                    *volp++ = v;
1433
                }
1434
            }
1435
        }
1436

    
1437
        /* frame rate emulation */
1438
        if (rate_emu) {
1439
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1440
            int64_t now = av_gettime() - ist->start;
1441
            if (pts > now)
1442
                usleep(pts - now);
1443
        }
1444

    
1445
        /* if output time reached then transcode raw format,
1446
           encode packets and output them */
1447
        if (start_time == 0 || ist->pts >= start_time)
1448
            for(i=0;i<nb_ostreams;i++) {
1449
                int frame_size;
1450

    
1451
                ost = ost_table[i];
1452
                if (ost->source_index == ist_index) {
1453
                    os = output_files[ost->file_index];
1454

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

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

    
1481
                        av_init_packet(&opkt);
1482

    
1483
                        if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1484
                            continue;
1485

    
1486
                        /* no reencoding needed : output the packet directly */
1487
                        /* force the input stream PTS */
1488

    
1489
                        avcodec_get_frame_defaults(&avframe);
1490
                        ost->st->codec->coded_frame= &avframe;
1491
                        avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1492

    
1493
                        if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1494
                            audio_size += data_size;
1495
                        else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1496
                            video_size += data_size;
1497
                            ost->sync_opts++;
1498
                        }
1499

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

    
1506
                        if (pkt->dts == AV_NOPTS_VALUE)
1507
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1508
                        else
1509
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1510
                        opkt.dts -= ost_tb_start_time;
1511

    
1512
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1513
                        opkt.flags= pkt->flags;
1514

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

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

    
1553
        for(i=0;i<nb_ostreams;i++) {
1554
            ost = ost_table[i];
1555
            if (ost->source_index == ist_index) {
1556
                AVCodecContext *enc= ost->st->codec;
1557
                os = output_files[ost->file_index];
1558

    
1559
                if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1560
                    continue;
1561
                if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1562
                    continue;
1563

    
1564
                if (ost->encoding_needed) {
1565
                    for(;;) {
1566
                        AVPacket pkt;
1567
                        int fifo_bytes;
1568
                        av_init_packet(&pkt);
1569
                        pkt.stream_index= ost->index;
1570

    
1571
                        switch(ost->st->codec->codec_type) {
1572
                        case CODEC_TYPE_AUDIO:
1573
                            fifo_bytes = av_fifo_size(ost->fifo);
1574
                            ret = 0;
1575
                            /* encode any samples remaining in fifo */
1576
                            if (fifo_bytes > 0) {
1577
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1578
                                int fs_tmp = enc->frame_size;
1579

    
1580
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1581
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1582
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1583
                                } else { /* pad */
1584
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1585
                                    if (samples_size < frame_bytes)
1586
                                        av_exit(1);
1587
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1588
                                }
1589

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

    
1622
                        if(ret<=0)
1623
                            break;
1624
                        pkt.data= bit_buffer;
1625
                        pkt.size= ret;
1626
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1627
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1628
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1629
                    }
1630
                }
1631
            }
1632
        }
1633
    }
1634

    
1635
    return 0;
1636
 fail_decode:
1637
    return -1;
1638
}
1639

    
1640
static void print_sdp(AVFormatContext **avc, int n)
1641
{
1642
    char sdp[2048];
1643

    
1644
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1645
    printf("SDP:\n%s\n", sdp);
1646
    fflush(stdout);
1647
}
1648

    
1649
/*
1650
 * The following code is the main loop of the file converter
1651
 */
1652
static int av_encode(AVFormatContext **output_files,
1653
                     int nb_output_files,
1654
                     AVFormatContext **input_files,
1655
                     int nb_input_files,
1656
                     AVStreamMap *stream_maps, int nb_stream_maps)
1657
{
1658
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1659
    AVFormatContext *is, *os;
1660
    AVCodecContext *codec, *icodec;
1661
    AVOutputStream *ost, **ost_table = NULL;
1662
    AVInputStream *ist, **ist_table = NULL;
1663
    AVInputFile *file_table;
1664
    char error[1024];
1665
    int key;
1666
    int want_sdp = 1;
1667
    uint8_t no_packet[MAX_FILES]={0};
1668
    int no_packet_count=0;
1669

    
1670
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1671
    if (!file_table)
1672
        goto fail;
1673

    
1674
    /* input stream init */
1675
    j = 0;
1676
    for(i=0;i<nb_input_files;i++) {
1677
        is = input_files[i];
1678
        file_table[i].ist_index = j;
1679
        file_table[i].nb_streams = is->nb_streams;
1680
        j += is->nb_streams;
1681
    }
1682
    nb_istreams = j;
1683

    
1684
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1685
    if (!ist_table)
1686
        goto fail;
1687

    
1688
    for(i=0;i<nb_istreams;i++) {
1689
        ist = av_mallocz(sizeof(AVInputStream));
1690
        if (!ist)
1691
            goto fail;
1692
        ist_table[i] = ist;
1693
    }
1694
    j = 0;
1695
    for(i=0;i<nb_input_files;i++) {
1696
        is = input_files[i];
1697
        for(k=0;k<is->nb_streams;k++) {
1698
            ist = ist_table[j++];
1699
            ist->st = is->streams[k];
1700
            ist->file_index = i;
1701
            ist->index = k;
1702
            ist->discard = 1; /* the stream is discarded by default
1703
                                 (changed later) */
1704

    
1705
            if (rate_emu) {
1706
                ist->start = av_gettime();
1707
            }
1708
        }
1709
    }
1710

    
1711
    /* output stream init */
1712
    nb_ostreams = 0;
1713
    for(i=0;i<nb_output_files;i++) {
1714
        os = output_files[i];
1715
        if (!os->nb_streams) {
1716
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1717
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1718
            av_exit(1);
1719
        }
1720
        nb_ostreams += os->nb_streams;
1721
    }
1722
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1723
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1724
        av_exit(1);
1725
    }
1726

    
1727
    /* Sanity check the mapping args -- do the input files & streams exist? */
1728
    for(i=0;i<nb_stream_maps;i++) {
1729
        int fi = stream_maps[i].file_index;
1730
        int si = stream_maps[i].stream_index;
1731

    
1732
        if (fi < 0 || fi > nb_input_files - 1 ||
1733
            si < 0 || si > file_table[fi].nb_streams - 1) {
1734
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1735
            av_exit(1);
1736
        }
1737
        fi = stream_maps[i].sync_file_index;
1738
        si = stream_maps[i].sync_stream_index;
1739
        if (fi < 0 || fi > nb_input_files - 1 ||
1740
            si < 0 || si > file_table[fi].nb_streams - 1) {
1741
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1742
            av_exit(1);
1743
        }
1744
    }
1745

    
1746
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1747
    if (!ost_table)
1748
        goto fail;
1749
    for(i=0;i<nb_ostreams;i++) {
1750
        ost = av_mallocz(sizeof(AVOutputStream));
1751
        if (!ost)
1752
            goto fail;
1753
        ost_table[i] = ost;
1754
    }
1755

    
1756
    n = 0;
1757
    for(k=0;k<nb_output_files;k++) {
1758
        os = output_files[k];
1759
        for(i=0;i<os->nb_streams;i++,n++) {
1760
            int found;
1761
            ost = ost_table[n];
1762
            ost->file_index = k;
1763
            ost->index = i;
1764
            ost->st = os->streams[i];
1765
            if (nb_stream_maps > 0) {
1766
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1767
                    stream_maps[n].stream_index;
1768

    
1769
                /* Sanity check that the stream types match */
1770
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1771
                    int i= ost->file_index;
1772
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1773
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1774
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1775
                        ost->file_index, ost->index);
1776
                    av_exit(1);
1777
                }
1778

    
1779
            } else {
1780
                int best_nb_frames=-1;
1781
                    /* get corresponding input stream index : we select the first one with the right type */
1782
                    found = 0;
1783
                    for(j=0;j<nb_istreams;j++) {
1784
                        int skip=0;
1785
                        ist = ist_table[j];
1786
                        if(opt_programid){
1787
                            int pi,si;
1788
                            AVFormatContext *f= input_files[ ist->file_index ];
1789
                            skip=1;
1790
                            for(pi=0; pi<f->nb_programs; pi++){
1791
                                AVProgram *p= f->programs[pi];
1792
                                if(p->id == opt_programid)
1793
                                    for(si=0; si<p->nb_stream_indexes; si++){
1794
                                        if(f->streams[ p->stream_index[si] ] == ist->st)
1795
                                            skip=0;
1796
                                    }
1797
                            }
1798
                        }
1799
                        if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
1800
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1801
                            if(best_nb_frames < ist->st->codec_info_nb_frames){
1802
                                best_nb_frames= ist->st->codec_info_nb_frames;
1803
                                ost->source_index = j;
1804
                                found = 1;
1805
                            }
1806
                        }
1807
                    }
1808

    
1809
                if (!found) {
1810
                    if(! opt_programid) {
1811
                        /* try again and reuse existing stream */
1812
                        for(j=0;j<nb_istreams;j++) {
1813
                            ist = ist_table[j];
1814
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
1815
                                && ist->st->discard != AVDISCARD_ALL) {
1816
                                ost->source_index = j;
1817
                                found = 1;
1818
                            }
1819
                        }
1820
                    }
1821
                    if (!found) {
1822
                        int i= ost->file_index;
1823
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1824
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1825
                                ost->file_index, ost->index);
1826
                        av_exit(1);
1827
                    }
1828
                }
1829
            }
1830
            ist = ist_table[ost->source_index];
1831
            ist->discard = 0;
1832
            ost->sync_ist = (nb_stream_maps > 0) ?
1833
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1834
                         stream_maps[n].sync_stream_index] : ist;
1835
        }
1836
    }
1837

    
1838
    /* for each output stream, we compute the right encoding parameters */
1839
    for(i=0;i<nb_ostreams;i++) {
1840
        AVMetadataTag *lang;
1841
        ost = ost_table[i];
1842
        os = output_files[ost->file_index];
1843
        ist = ist_table[ost->source_index];
1844

    
1845
        codec = ost->st->codec;
1846
        icodec = ist->st->codec;
1847

    
1848
        if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1849
            &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1850
            av_metadata_set(&ost->st->metadata, "language", lang->value);
1851

    
1852
        ost->st->disposition = ist->st->disposition;
1853
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1854
        codec->chroma_sample_location = icodec->chroma_sample_location;
1855

    
1856
        if (ost->st->stream_copy) {
1857
            /* if stream_copy is selected, no need to decode or encode */
1858
            codec->codec_id = icodec->codec_id;
1859
            codec->codec_type = icodec->codec_type;
1860

    
1861
            if(!codec->codec_tag){
1862
                if(   !os->oformat->codec_tag
1863
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1864
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1865
                    codec->codec_tag = icodec->codec_tag;
1866
            }
1867

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

    
1970
                    ost->original_height = icodec->height;
1971
                    ost->original_width  = icodec->width;
1972

    
1973
                    codec->bits_per_raw_sample= 0;
1974
                }
1975
                ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
1976
                ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
1977
                ost->resample_pix_fmt= icodec->pix_fmt;
1978
                ost->encoding_needed = 1;
1979
                ist->decoding_needed = 1;
1980
                break;
1981
            case CODEC_TYPE_SUBTITLE:
1982
                ost->encoding_needed = 1;
1983
                ist->decoding_needed = 1;
1984
                break;
1985
            default:
1986
                abort();
1987
                break;
1988
            }
1989
            /* two pass mode */
1990
            if (ost->encoding_needed &&
1991
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1992
                char logfilename[1024];
1993
                FILE *f;
1994
                int size;
1995
                char *logbuffer;
1996

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

    
2035
    if (!bit_buffer)
2036
        bit_buffer = av_malloc(bit_buffer_size);
2037
    if (!bit_buffer) {
2038
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2039
                bit_buffer_size);
2040
        ret = AVERROR(ENOMEM);
2041
        goto fail;
2042
    }
2043

    
2044
    /* open each encoder */
2045
    for(i=0;i<nb_ostreams;i++) {
2046
        ost = ost_table[i];
2047
        if (ost->encoding_needed) {
2048
            AVCodec *codec = output_codecs[i];
2049
            if (!codec)
2050
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2051
            if (!codec) {
2052
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2053
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2054
                ret = AVERROR(EINVAL);
2055
                goto dump_format;
2056
            }
2057
            if (avcodec_open(ost->st->codec, codec) < 0) {
2058
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2059
                        ost->file_index, ost->index);
2060
                ret = AVERROR(EINVAL);
2061
                goto dump_format;
2062
            }
2063
            extra_size += ost->st->codec->extradata_size;
2064
        }
2065
    }
2066

    
2067
    /* open each decoder */
2068
    for(i=0;i<nb_istreams;i++) {
2069
        ist = ist_table[i];
2070
        if (ist->decoding_needed) {
2071
            AVCodec *codec = input_codecs[i];
2072
            if (!codec)
2073
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2074
            if (!codec) {
2075
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2076
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2077
                ret = AVERROR(EINVAL);
2078
                goto dump_format;
2079
            }
2080
            if (avcodec_open(ist->st->codec, codec) < 0) {
2081
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2082
                        ist->file_index, ist->index);
2083
                ret = AVERROR(EINVAL);
2084
                goto dump_format;
2085
            }
2086
            //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2087
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2088
        }
2089
    }
2090

    
2091
    /* init pts */
2092
    for(i=0;i<nb_istreams;i++) {
2093
        AVStream *st;
2094
        ist = ist_table[i];
2095
        st= ist->st;
2096
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2097
        ist->next_pts = AV_NOPTS_VALUE;
2098
        ist->is_start = 1;
2099
    }
2100

    
2101
    /* set meta data information from input file if required */
2102
    for (i=0;i<nb_meta_data_maps;i++) {
2103
        AVFormatContext *out_file;
2104
        AVFormatContext *in_file;
2105
        AVMetadataTag *mtag;
2106

    
2107
        int out_file_index = meta_data_maps[i].out_file;
2108
        int in_file_index = meta_data_maps[i].in_file;
2109
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2110
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2111
                     out_file_index, out_file_index, in_file_index);
2112
            ret = AVERROR(EINVAL);
2113
            goto dump_format;
2114
        }
2115
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2116
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2117
                     in_file_index, out_file_index, in_file_index);
2118
            ret = AVERROR(EINVAL);
2119
            goto dump_format;
2120
        }
2121

    
2122
        out_file = output_files[out_file_index];
2123
        in_file = input_files[in_file_index];
2124

    
2125

    
2126
        mtag=NULL;
2127
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2128
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2129
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2130
                                    in_file->iformat->metadata_conv);
2131
    }
2132

    
2133
    /* open files and write file headers */
2134
    for(i=0;i<nb_output_files;i++) {
2135
        os = output_files[i];
2136
        if (av_write_header(os) < 0) {
2137
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2138
            ret = AVERROR(EINVAL);
2139
            goto dump_format;
2140
        }
2141
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2142
            want_sdp = 0;
2143
        }
2144
    }
2145

    
2146
 dump_format:
2147
    /* dump the file output parameters - cannot be done before in case
2148
       of stream copy */
2149
    for(i=0;i<nb_output_files;i++) {
2150
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2151
    }
2152

    
2153
    /* dump the stream mapping */
2154
    if (verbose >= 0) {
2155
        fprintf(stderr, "Stream mapping:\n");
2156
        for(i=0;i<nb_ostreams;i++) {
2157
            ost = ost_table[i];
2158
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2159
                    ist_table[ost->source_index]->file_index,
2160
                    ist_table[ost->source_index]->index,
2161
                    ost->file_index,
2162
                    ost->index);
2163
            if (ost->sync_ist != ist_table[ost->source_index])
2164
                fprintf(stderr, " [sync #%d.%d]",
2165
                        ost->sync_ist->file_index,
2166
                        ost->sync_ist->index);
2167
            fprintf(stderr, "\n");
2168
        }
2169
    }
2170

    
2171
    if (ret) {
2172
        fprintf(stderr, "%s\n", error);
2173
        goto fail;
2174
    }
2175

    
2176
    if (want_sdp) {
2177
        print_sdp(output_files, nb_output_files);
2178
    }
2179

    
2180
    if (!using_stdin && verbose >= 0) {
2181
        fprintf(stderr, "Press [q] to stop encoding\n");
2182
        url_set_interrupt_cb(decode_interrupt_cb);
2183
    }
2184
    term_init();
2185

    
2186
    timer_start = av_gettime();
2187

    
2188
    for(; received_sigterm == 0;) {
2189
        int file_index, ist_index;
2190
        AVPacket pkt;
2191
        double ipts_min;
2192
        double opts_min;
2193

    
2194
    redo:
2195
        ipts_min= 1e100;
2196
        opts_min= 1e100;
2197
        /* if 'q' pressed, exits */
2198
        if (!using_stdin) {
2199
            if (q_pressed)
2200
                break;
2201
            /* read_key() returns 0 on EOF */
2202
            key = read_key();
2203
            if (key == 'q')
2204
                break;
2205
        }
2206

    
2207
        /* select the stream that we must read now by looking at the
2208
           smallest output pts */
2209
        file_index = -1;
2210
        for(i=0;i<nb_ostreams;i++) {
2211
            double ipts, opts;
2212
            ost = ost_table[i];
2213
            os = output_files[ost->file_index];
2214
            ist = ist_table[ost->source_index];
2215
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2216
                continue;
2217
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2218
            ipts = (double)ist->pts;
2219
            if (!file_table[ist->file_index].eof_reached){
2220
                if(ipts < ipts_min) {
2221
                    ipts_min = ipts;
2222
                    if(input_sync ) file_index = ist->file_index;
2223
                }
2224
                if(opts < opts_min) {
2225
                    opts_min = opts;
2226
                    if(!input_sync) file_index = ist->file_index;
2227
                }
2228
            }
2229
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2230
                file_index= -1;
2231
                break;
2232
            }
2233
        }
2234
        /* if none, if is finished */
2235
        if (file_index < 0) {
2236
            if(no_packet_count){
2237
                no_packet_count=0;
2238
                memset(no_packet, 0, sizeof(no_packet));
2239
                usleep(10000);
2240
                continue;
2241
            }
2242
            break;
2243
        }
2244

    
2245
        /* finish if limit size exhausted */
2246
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2247
            break;
2248

    
2249
        /* read a frame from it and output it in the fifo */
2250
        is = input_files[file_index];
2251
        ret= av_read_frame(is, &pkt);
2252
        if(ret == AVERROR(EAGAIN)){
2253
            no_packet[file_index]=1;
2254
            no_packet_count++;
2255
            continue;
2256
        }
2257
        if (ret < 0) {
2258
            file_table[file_index].eof_reached = 1;
2259
            if (opt_shortest)
2260
                break;
2261
            else
2262
                continue;
2263
        }
2264

    
2265
        no_packet_count=0;
2266
        memset(no_packet, 0, sizeof(no_packet));
2267

    
2268
        if (do_pkt_dump) {
2269
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2270
        }
2271
        /* the following test is needed in case new streams appear
2272
           dynamically in stream : we ignore them */
2273
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2274
            goto discard_packet;
2275
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2276
        ist = ist_table[ist_index];
2277
        if (ist->discard)
2278
            goto discard_packet;
2279

    
2280
        if (pkt.dts != AV_NOPTS_VALUE)
2281
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2282
        if (pkt.pts != AV_NOPTS_VALUE)
2283
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2284

    
2285
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2286
            if(pkt.pts != AV_NOPTS_VALUE)
2287
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2288
            if(pkt.dts != AV_NOPTS_VALUE)
2289
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2290
        }
2291

    
2292
//        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);
2293
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2294
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2295
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2296
            int64_t delta= pkt_dts - ist->next_pts;
2297
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2298
                input_files_ts_offset[ist->file_index]-= delta;
2299
                if (verbose > 2)
2300
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2301
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2302
                if(pkt.pts != AV_NOPTS_VALUE)
2303
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2304
            }
2305
        }
2306

    
2307
        /* finish if recording time exhausted */
2308
        if (av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2309
            ist->is_past_recording_time = 1;
2310
            goto discard_packet;
2311
        }
2312

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

    
2316
            if (verbose >= 0)
2317
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2318
                        ist->file_index, ist->index);
2319
            if (exit_on_error)
2320
                av_exit(1);
2321
            av_free_packet(&pkt);
2322
            goto redo;
2323
        }
2324

    
2325
    discard_packet:
2326
        av_free_packet(&pkt);
2327

    
2328
        /* dump report by using the output first video and audio streams */
2329
        print_report(output_files, ost_table, nb_ostreams, 0);
2330
    }
2331

    
2332
    /* at the end of stream, we must flush the decoder buffers */
2333
    for(i=0;i<nb_istreams;i++) {
2334
        ist = ist_table[i];
2335
        if (ist->decoding_needed) {
2336
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2337
        }
2338
    }
2339

    
2340
    term_exit();
2341

    
2342
    /* write the trailer if needed and close file */
2343
    for(i=0;i<nb_output_files;i++) {
2344
        os = output_files[i];
2345
        av_write_trailer(os);
2346
    }
2347

    
2348
    /* dump report by using the first video and audio streams */
2349
    print_report(output_files, ost_table, nb_ostreams, 1);
2350

    
2351
    /* close each encoder */
2352
    for(i=0;i<nb_ostreams;i++) {
2353
        ost = ost_table[i];
2354
        if (ost->encoding_needed) {
2355
            av_freep(&ost->st->codec->stats_in);
2356
            avcodec_close(ost->st->codec);
2357
        }
2358
    }
2359

    
2360
    /* close each decoder */
2361
    for(i=0;i<nb_istreams;i++) {
2362
        ist = ist_table[i];
2363
        if (ist->decoding_needed) {
2364
            avcodec_close(ist->st->codec);
2365
        }
2366
    }
2367

    
2368
    /* finished ! */
2369
    ret = 0;
2370

    
2371
 fail:
2372
    av_freep(&bit_buffer);
2373
    av_free(file_table);
2374

    
2375
    if (ist_table) {
2376
        for(i=0;i<nb_istreams;i++) {
2377
            ist = ist_table[i];
2378
            av_free(ist);
2379
        }
2380
        av_free(ist_table);
2381
    }
2382
    if (ost_table) {
2383
        for(i=0;i<nb_ostreams;i++) {
2384
            ost = ost_table[i];
2385
            if (ost) {
2386
                if (ost->logfile) {
2387
                    fclose(ost->logfile);
2388
                    ost->logfile = NULL;
2389
                }
2390
                av_fifo_free(ost->fifo); /* works even if fifo is not
2391
                                             initialized but set to zero */
2392
                av_free(ost->pict_tmp.data[0]);
2393
                if (ost->video_resample)
2394
                    sws_freeContext(ost->img_resample_ctx);
2395
                if (ost->resample)
2396
                    audio_resample_close(ost->resample);
2397
                if (ost->reformat_ctx)
2398
                    av_audio_convert_free(ost->reformat_ctx);
2399
                av_free(ost);
2400
            }
2401
        }
2402
        av_free(ost_table);
2403
    }
2404
    return ret;
2405
}
2406

    
2407
static void opt_format(const char *arg)
2408
{
2409
    /* compatibility stuff for pgmyuv */
2410
    if (!strcmp(arg, "pgmyuv")) {
2411
        pgmyuv_compatibility_hack=1;
2412
//        opt_image_format(arg);
2413
        arg = "image2";
2414
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2415
    }
2416

    
2417
    last_asked_format = arg;
2418
}
2419

    
2420
static void opt_video_rc_override_string(const char *arg)
2421
{
2422
    video_rc_override_string = arg;
2423
}
2424

    
2425
static int opt_me_threshold(const char *opt, const char *arg)
2426
{
2427
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2428
    return 0;
2429
}
2430

    
2431
static int opt_verbose(const char *opt, const char *arg)
2432
{
2433
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2434
    return 0;
2435
}
2436

    
2437
static int opt_frame_rate(const char *opt, const char *arg)
2438
{
2439
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2440
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2441
        av_exit(1);
2442
    }
2443
    return 0;
2444
}
2445

    
2446
static int opt_bitrate(const char *opt, const char *arg)
2447
{
2448
    int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2449

    
2450
    opt_default(opt, arg);
2451

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

    
2455
    return 0;
2456
}
2457

    
2458
static void opt_frame_crop_top(const char *arg)
2459
{
2460
    frame_topBand = atoi(arg);
2461
    if (frame_topBand < 0) {
2462
        fprintf(stderr, "Incorrect top crop size\n");
2463
        av_exit(1);
2464
    }
2465
    if ((frame_topBand) >= frame_height){
2466
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2467
        av_exit(1);
2468
    }
2469
    frame_height -= frame_topBand;
2470
}
2471

    
2472
static void opt_frame_crop_bottom(const char *arg)
2473
{
2474
    frame_bottomBand = atoi(arg);
2475
    if (frame_bottomBand < 0) {
2476
        fprintf(stderr, "Incorrect bottom crop size\n");
2477
        av_exit(1);
2478
    }
2479
    if ((frame_bottomBand) >= frame_height){
2480
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2481
        av_exit(1);
2482
    }
2483
    frame_height -= frame_bottomBand;
2484
}
2485

    
2486
static void opt_frame_crop_left(const char *arg)
2487
{
2488
    frame_leftBand = atoi(arg);
2489
    if (frame_leftBand < 0) {
2490
        fprintf(stderr, "Incorrect left crop size\n");
2491
        av_exit(1);
2492
    }
2493
    if ((frame_leftBand) >= frame_width){
2494
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2495
        av_exit(1);
2496
    }
2497
    frame_width -= frame_leftBand;
2498
}
2499

    
2500
static void opt_frame_crop_right(const char *arg)
2501
{
2502
    frame_rightBand = atoi(arg);
2503
    if (frame_rightBand < 0) {
2504
        fprintf(stderr, "Incorrect right crop size\n");
2505
        av_exit(1);
2506
    }
2507
    if ((frame_rightBand) >= frame_width){
2508
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2509
        av_exit(1);
2510
    }
2511
    frame_width -= frame_rightBand;
2512
}
2513

    
2514
static void opt_frame_size(const char *arg)
2515
{
2516
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2517
        fprintf(stderr, "Incorrect frame size\n");
2518
        av_exit(1);
2519
    }
2520
}
2521

    
2522
static void opt_pad_color(const char *arg) {
2523
    /* Input is expected to be six hex digits similar to
2524
       how colors are expressed in html tags (but without the #) */
2525
    int rgb = strtol(arg, NULL, 16);
2526
    int r,g,b;
2527

    
2528
    r = (rgb >> 16);
2529
    g = ((rgb >> 8) & 255);
2530
    b = (rgb & 255);
2531

    
2532
    padcolor[0] = RGB_TO_Y(r,g,b);
2533
    padcolor[1] = RGB_TO_U(r,g,b,0);
2534
    padcolor[2] = RGB_TO_V(r,g,b,0);
2535
}
2536

    
2537
static void opt_frame_pad_top(const char *arg)
2538
{
2539
    frame_padtop = atoi(arg);
2540
    if (frame_padtop < 0) {
2541
        fprintf(stderr, "Incorrect top pad size\n");
2542
        av_exit(1);
2543
    }
2544
}
2545

    
2546
static void opt_frame_pad_bottom(const char *arg)
2547
{
2548
    frame_padbottom = atoi(arg);
2549
    if (frame_padbottom < 0) {
2550
        fprintf(stderr, "Incorrect bottom pad size\n");
2551
        av_exit(1);
2552
    }
2553
}
2554

    
2555

    
2556
static void opt_frame_pad_left(const char *arg)
2557
{
2558
    frame_padleft = atoi(arg);
2559
    if (frame_padleft < 0) {
2560
        fprintf(stderr, "Incorrect left pad size\n");
2561
        av_exit(1);
2562
    }
2563
}
2564

    
2565

    
2566
static void opt_frame_pad_right(const char *arg)
2567
{
2568
    frame_padright = atoi(arg);
2569
    if (frame_padright < 0) {
2570
        fprintf(stderr, "Incorrect right pad size\n");
2571
        av_exit(1);
2572
    }
2573
}
2574

    
2575
static void opt_frame_pix_fmt(const char *arg)
2576
{
2577
    if (strcmp(arg, "list")) {
2578
        frame_pix_fmt = av_get_pix_fmt(arg);
2579
        if (frame_pix_fmt == PIX_FMT_NONE) {
2580
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2581
            av_exit(1);
2582
        }
2583
    } else {
2584
        show_pix_fmts();
2585
        av_exit(0);
2586
    }
2587
}
2588

    
2589
static void opt_frame_aspect_ratio(const char *arg)
2590
{
2591
    int x = 0, y = 0;
2592
    double ar = 0;
2593
    const char *p;
2594
    char *end;
2595

    
2596
    p = strchr(arg, ':');
2597
    if (p) {
2598
        x = strtol(arg, &end, 10);
2599
        if (end == p)
2600
            y = strtol(end+1, &end, 10);
2601
        if (x > 0 && y > 0)
2602
            ar = (double)x / (double)y;
2603
    } else
2604
        ar = strtod(arg, NULL);
2605

    
2606
    if (!ar) {
2607
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2608
        av_exit(1);
2609
    }
2610
    frame_aspect_ratio = ar;
2611
}
2612

    
2613
static int opt_metadata(const char *opt, const char *arg)
2614
{
2615
    char *mid= strchr(arg, '=');
2616

    
2617
    if(!mid){
2618
        fprintf(stderr, "Missing =\n");
2619
        av_exit(1);
2620
    }
2621
    *mid++= 0;
2622

    
2623
    metadata_count++;
2624
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2625
    metadata[metadata_count-1].key  = av_strdup(arg);
2626
    metadata[metadata_count-1].value= av_strdup(mid);
2627

    
2628
    return 0;
2629
}
2630

    
2631
static void opt_qscale(const char *arg)
2632
{
2633
    video_qscale = atof(arg);
2634
    if (video_qscale <= 0 ||
2635
        video_qscale > 255) {
2636
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2637
        av_exit(1);
2638
    }
2639
}
2640

    
2641
static void opt_top_field_first(const char *arg)
2642
{
2643
    top_field_first= atoi(arg);
2644
}
2645

    
2646
static int opt_thread_count(const char *opt, const char *arg)
2647
{
2648
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2649
#if !HAVE_THREADS
2650
    if (verbose >= 0)
2651
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2652
#endif
2653
    return 0;
2654
}
2655

    
2656
static void opt_audio_sample_fmt(const char *arg)
2657
{
2658
    if (strcmp(arg, "list"))
2659
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2660
    else {
2661
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2662
        av_exit(0);
2663
    }
2664
}
2665

    
2666
static int opt_audio_rate(const char *opt, const char *arg)
2667
{
2668
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2669
    return 0;
2670
}
2671

    
2672
static int opt_audio_channels(const char *opt, const char *arg)
2673
{
2674
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2675
    return 0;
2676
}
2677

    
2678
static void opt_video_channel(const char *arg)
2679
{
2680
    video_channel = strtol(arg, NULL, 0);
2681
}
2682

    
2683
static void opt_video_standard(const char *arg)
2684
{
2685
    video_standard = av_strdup(arg);
2686
}
2687

    
2688
static void opt_codec(int *pstream_copy, char **pcodec_name,
2689
                      int codec_type, const char *arg)
2690
{
2691
    av_freep(pcodec_name);
2692
    if (!strcmp(arg, "copy")) {
2693
        *pstream_copy = 1;
2694
    } else {
2695
        *pcodec_name = av_strdup(arg);
2696
    }
2697
}
2698

    
2699
static void opt_audio_codec(const char *arg)
2700
{
2701
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2702
}
2703

    
2704
static void opt_audio_tag(const char *arg)
2705
{
2706
    char *tail;
2707
    audio_codec_tag= strtol(arg, &tail, 0);
2708

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

    
2713
static void opt_video_tag(const char *arg)
2714
{
2715
    char *tail;
2716
    video_codec_tag= strtol(arg, &tail, 0);
2717

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

    
2722
static void opt_video_codec(const char *arg)
2723
{
2724
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2725
}
2726

    
2727
static void opt_subtitle_codec(const char *arg)
2728
{
2729
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2730
}
2731

    
2732
static void opt_subtitle_tag(const char *arg)
2733
{
2734
    char *tail;
2735
    subtitle_codec_tag= strtol(arg, &tail, 0);
2736

    
2737
    if(!tail || *tail)
2738
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2739
}
2740

    
2741
static void opt_map(const char *arg)
2742
{
2743
    AVStreamMap *m;
2744
    char *p;
2745

    
2746
    m = &stream_maps[nb_stream_maps++];
2747

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

    
2752
    m->stream_index = strtol(p, &p, 0);
2753
    if (*p) {
2754
        p++;
2755
        m->sync_file_index = strtol(p, &p, 0);
2756
        if (*p)
2757
            p++;
2758
        m->sync_stream_index = strtol(p, &p, 0);
2759
    } else {
2760
        m->sync_file_index = m->file_index;
2761
        m->sync_stream_index = m->stream_index;
2762
    }
2763
}
2764

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

    
2770
    m = &meta_data_maps[nb_meta_data_maps++];
2771

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

    
2776
    m->in_file = strtol(p, &p, 0);
2777
}
2778

    
2779
static void opt_input_ts_scale(const char *arg)
2780
{
2781
    unsigned int stream;
2782
    double scale;
2783
    char *p;
2784

    
2785
    stream = strtol(arg, &p, 0);
2786
    if (*p)
2787
        p++;
2788
    scale= strtod(p, &p);
2789

    
2790
    if(stream >= MAX_STREAMS)
2791
        av_exit(1);
2792

    
2793
    input_files_ts_scale[nb_input_files][stream]= scale;
2794
}
2795

    
2796
static int opt_recording_time(const char *opt, const char *arg)
2797
{
2798
    recording_time = parse_time_or_die(opt, arg, 1);
2799
    return 0;
2800
}
2801

    
2802
static int opt_start_time(const char *opt, const char *arg)
2803
{
2804
    start_time = parse_time_or_die(opt, arg, 1);
2805
    return 0;
2806
}
2807

    
2808
static int opt_rec_timestamp(const char *opt, const char *arg)
2809
{
2810
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2811
    return 0;
2812
}
2813

    
2814
static int opt_input_ts_offset(const char *opt, const char *arg)
2815
{
2816
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2817
    return 0;
2818
}
2819

    
2820
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2821
{
2822
    const char *codec_string = encoder ? "encoder" : "decoder";
2823
    AVCodec *codec;
2824

    
2825
    if(!name)
2826
        return CODEC_ID_NONE;
2827
    codec = encoder ?
2828
        avcodec_find_encoder_by_name(name) :
2829
        avcodec_find_decoder_by_name(name);
2830
    if(!codec) {
2831
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2832
        av_exit(1);
2833
    }
2834
    if(codec->type != type) {
2835
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2836
        av_exit(1);
2837
    }
2838
    return codec->id;
2839
}
2840

    
2841
static void opt_input_file(const char *filename)
2842
{
2843
    AVFormatContext *ic;
2844
    AVFormatParameters params, *ap = &params;
2845
    AVInputFormat *file_iformat = NULL;
2846
    int err, i, ret, rfps, rfps_base;
2847
    int64_t timestamp;
2848

    
2849
    if (last_asked_format) {
2850
        file_iformat = av_find_input_format(last_asked_format);
2851
        last_asked_format = NULL;
2852
    }
2853

    
2854
    if (!strcmp(filename, "-"))
2855
        filename = "pipe:";
2856

    
2857
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2858
                    !strcmp(filename, "/dev/stdin");
2859

    
2860
    /* get default parameters from command line */
2861
    ic = avformat_alloc_context();
2862
    if (!ic) {
2863
        print_error(filename, AVERROR(ENOMEM));
2864
        av_exit(1);
2865
    }
2866

    
2867
    memset(ap, 0, sizeof(*ap));
2868
    ap->prealloced_context = 1;
2869
    ap->sample_rate = audio_sample_rate;
2870
    ap->channels = audio_channels;
2871
    ap->time_base.den = frame_rate.num;
2872
    ap->time_base.num = frame_rate.den;
2873
    ap->width = frame_width + frame_padleft + frame_padright;
2874
    ap->height = frame_height + frame_padtop + frame_padbottom;
2875
    ap->pix_fmt = frame_pix_fmt;
2876
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2877
    ap->channel = video_channel;
2878
    ap->standard = video_standard;
2879

    
2880
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2881

    
2882
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2883
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2884
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2885
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2886

    
2887
    if(pgmyuv_compatibility_hack)
2888
        ic->video_codec_id= CODEC_ID_PGMYUV;
2889

    
2890
    /* open the input file with generic libav function */
2891
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2892
    if (err < 0) {
2893
        print_error(filename, err);
2894
        av_exit(1);
2895
    }
2896
    if(opt_programid) {
2897
        int i, j;
2898
        int found=0;
2899
        for(i=0; i<ic->nb_streams; i++){
2900
            ic->streams[i]->discard= AVDISCARD_ALL;
2901
        }
2902
        for(i=0; i<ic->nb_programs; i++){
2903
            AVProgram *p= ic->programs[i];
2904
            if(p->id != opt_programid){
2905
                p->discard = AVDISCARD_ALL;
2906
            }else{
2907
                found=1;
2908
                for(j=0; j<p->nb_stream_indexes; j++){
2909
                    ic->streams[p->stream_index[j]]->discard= 0;
2910
                }
2911
            }
2912
        }
2913
        if(!found){
2914
            fprintf(stderr, "Specified program id not found\n");
2915
            av_exit(1);
2916
        }
2917
        opt_programid=0;
2918
    }
2919

    
2920
    ic->loop_input = loop_input;
2921

    
2922
    /* If not enough info to get the stream parameters, we decode the
2923
       first frames to get it. (used in mpeg case for example) */
2924
    ret = av_find_stream_info(ic);
2925
    if (ret < 0 && verbose >= 0) {
2926
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
2927
        av_exit(1);
2928
    }
2929

    
2930
    timestamp = start_time;
2931
    /* add the stream start time */
2932
    if (ic->start_time != AV_NOPTS_VALUE)
2933
        timestamp += ic->start_time;
2934

    
2935
    /* if seeking requested, we execute it */
2936
    if (start_time != 0) {
2937
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2938
        if (ret < 0) {
2939
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
2940
                    filename, (double)timestamp / AV_TIME_BASE);
2941
        }
2942
        /* reset seek info */
2943
        start_time = 0;
2944
    }
2945

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

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

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

    
2989
                    (float)rfps / rfps_base, rfps, rfps_base);
2990
            }
2991
            /* update the current frame rate to match the stream frame rate */
2992
            frame_rate.num = rfps;
2993
            frame_rate.den = rfps_base;
2994

    
2995
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2996
            if(video_disable)
2997
                st->discard= AVDISCARD_ALL;
2998
            else if(video_discard)
2999
                st->discard= video_discard;
3000
            break;
3001
        case CODEC_TYPE_DATA:
3002
            break;
3003
        case CODEC_TYPE_SUBTITLE:
3004
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3005
            if(subtitle_disable)
3006
                st->discard = AVDISCARD_ALL;
3007
            break;
3008
        case CODEC_TYPE_ATTACHMENT:
3009
        case CODEC_TYPE_UNKNOWN:
3010
            nb_icodecs++;
3011
            break;
3012
        default:
3013
            abort();
3014
        }
3015
    }
3016

    
3017
    input_files[nb_input_files] = ic;
3018
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3019
    /* dump the file content */
3020
    if (verbose >= 0)
3021
        dump_format(ic, nb_input_files, filename, 0);
3022

    
3023
    nb_input_files++;
3024

    
3025
    video_channel = 0;
3026

    
3027
    av_freep(&video_codec_name);
3028
    av_freep(&audio_codec_name);
3029
    av_freep(&subtitle_codec_name);
3030
}
3031

    
3032
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3033
                                         int *has_subtitle_ptr)
3034
{
3035
    int has_video, has_audio, has_subtitle, i, j;
3036
    AVFormatContext *ic;
3037

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

    
3069
static void new_video_stream(AVFormatContext *oc)
3070
{
3071
    AVStream *st;
3072
    AVCodecContext *video_enc;
3073
    enum CodecID codec_id;
3074

    
3075
    st = av_new_stream(oc, oc->nb_streams);
3076
    if (!st) {
3077
        fprintf(stderr, "Could not alloc stream\n");
3078
        av_exit(1);
3079
    }
3080
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3081
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3082
    video_bitstream_filters= NULL;
3083

    
3084
    avcodec_thread_init(st->codec, thread_count);
3085

    
3086
    video_enc = st->codec;
3087

    
3088
    if(video_codec_tag)
3089
        video_enc->codec_tag= video_codec_tag;
3090

    
3091
    if(   (video_global_header&1)
3092
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3093
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3094
        avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3095
    }
3096
    if(video_global_header&2){
3097
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3098
        avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3099
    }
3100

    
3101
    if (video_stream_copy) {
3102
        st->stream_copy = 1;
3103
        video_enc->codec_type = CODEC_TYPE_VIDEO;
3104
        video_enc->sample_aspect_ratio =
3105
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3106
    } else {
3107
        const char *p;
3108
        int i;
3109
        AVCodec *codec;
3110
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3111

    
3112
        if (video_codec_name) {
3113
            codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3114
            codec = avcodec_find_encoder_by_name(video_codec_name);
3115
            output_codecs[nb_ocodecs] = codec;
3116
        } else {
3117
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3118
            codec = avcodec_find_encoder(codec_id);
3119
        }
3120

    
3121
        video_enc->codec_id = codec_id;
3122

    
3123
        set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3124

    
3125
        if (codec && codec->supported_framerates && !force_fps)
3126
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3127
        video_enc->time_base.den = fps.num;
3128
        video_enc->time_base.num = fps.den;
3129

    
3130
        video_enc->width = frame_width + frame_padright + frame_padleft;
3131
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3132
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3133
        video_enc->pix_fmt = frame_pix_fmt;
3134
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3135

    
3136
        if(codec && codec->pix_fmts){
3137
            const enum PixelFormat *p= codec->pix_fmts;
3138
            for(; *p!=-1; p++){
3139
                if(*p == video_enc->pix_fmt)
3140
                    break;
3141
            }
3142
            if(*p == -1)
3143
                video_enc->pix_fmt = codec->pix_fmts[0];
3144
        }
3145

    
3146
        if (intra_only)
3147
            video_enc->gop_size = 0;
3148
        if (video_qscale || same_quality) {
3149
            video_enc->flags |= CODEC_FLAG_QSCALE;
3150
            video_enc->global_quality=
3151
                st->quality = FF_QP2LAMBDA * video_qscale;
3152
        }
3153

    
3154
        if(intra_matrix)
3155
            video_enc->intra_matrix = intra_matrix;
3156
        if(inter_matrix)
3157
            video_enc->inter_matrix = inter_matrix;
3158

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

    
3189
        if (do_psnr)
3190
            video_enc->flags|= CODEC_FLAG_PSNR;
3191

    
3192
        /* two pass mode */
3193
        if (do_pass) {
3194
            if (do_pass == 1) {
3195
                video_enc->flags |= CODEC_FLAG_PASS1;
3196
            } else {
3197
                video_enc->flags |= CODEC_FLAG_PASS2;
3198
            }
3199
        }
3200
    }
3201
    nb_ocodecs++;
3202
    if (video_language) {
3203
        av_metadata_set(&st->metadata, "language", video_language);
3204
        av_freep(&video_language);
3205
    }
3206

    
3207
    /* reset some key parameters */
3208
    video_disable = 0;
3209
    av_freep(&video_codec_name);
3210
    video_stream_copy = 0;
3211
}
3212

    
3213
static void new_audio_stream(AVFormatContext *oc)
3214
{
3215
    AVStream *st;
3216
    AVCodecContext *audio_enc;
3217
    enum CodecID codec_id;
3218

    
3219
    st = av_new_stream(oc, oc->nb_streams);
3220
    if (!st) {
3221
        fprintf(stderr, "Could not alloc stream\n");
3222
        av_exit(1);
3223
    }
3224
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3225

    
3226
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3227
    audio_bitstream_filters= NULL;
3228

    
3229
    avcodec_thread_init(st->codec, thread_count);
3230

    
3231
    audio_enc = st->codec;
3232
    audio_enc->codec_type = CODEC_TYPE_AUDIO;
3233

    
3234
    if(audio_codec_tag)
3235
        audio_enc->codec_tag= audio_codec_tag;
3236

    
3237
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3238
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3239
        avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3240
    }
3241
    if (audio_stream_copy) {
3242
        st->stream_copy = 1;
3243
        audio_enc->channels = audio_channels;
3244
    } else {
3245
        AVCodec *codec;
3246

    
3247
        set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3248

    
3249
        if (audio_codec_name) {
3250
            codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3251
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3252
            output_codecs[nb_ocodecs] = codec;
3253
        } else {
3254
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3255
            codec = avcodec_find_encoder(codec_id);
3256
        }
3257
        audio_enc->codec_id = codec_id;
3258

    
3259
        if (audio_qscale > QSCALE_NONE) {
3260
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3261
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3262
        }
3263
        audio_enc->channels = audio_channels;
3264
        audio_enc->sample_fmt = audio_sample_fmt;
3265
        audio_enc->channel_layout = channel_layout;
3266
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3267
            audio_enc->channel_layout = 0;
3268

    
3269
        if(codec && codec->sample_fmts){
3270
            const enum SampleFormat *p= codec->sample_fmts;
3271
            for(; *p!=-1; p++){
3272
                if(*p == audio_enc->sample_fmt)
3273
                    break;
3274
            }
3275
            if(*p == -1)
3276
                audio_enc->sample_fmt = codec->sample_fmts[0];
3277
        }
3278
    }
3279
    nb_ocodecs++;
3280
    audio_enc->sample_rate = audio_sample_rate;
3281
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3282
    if (audio_language) {
3283
        av_metadata_set(&st->metadata, "language", audio_language);
3284
        av_freep(&audio_language);
3285
    }
3286

    
3287
    /* reset some key parameters */
3288
    audio_disable = 0;
3289
    av_freep(&audio_codec_name);
3290
    audio_stream_copy = 0;
3291
}
3292

    
3293
static void new_subtitle_stream(AVFormatContext *oc)
3294
{
3295
    AVStream *st;
3296
    AVCodecContext *subtitle_enc;
3297

    
3298
    st = av_new_stream(oc, oc->nb_streams);
3299
    if (!st) {
3300
        fprintf(stderr, "Could not alloc stream\n");
3301
        av_exit(1);
3302
    }
3303
    avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3304

    
3305
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3306
    subtitle_bitstream_filters= NULL;
3307

    
3308
    subtitle_enc = st->codec;
3309
    subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3310

    
3311
    if(subtitle_codec_tag)
3312
        subtitle_enc->codec_tag= subtitle_codec_tag;
3313

    
3314
    if (subtitle_stream_copy) {
3315
        st->stream_copy = 1;
3316
    } else {
3317
        set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3318
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3319
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3320
    }
3321
    nb_ocodecs++;
3322

    
3323
    if (subtitle_language) {
3324
        av_metadata_set(&st->metadata, "language", subtitle_language);
3325
        av_freep(&subtitle_language);
3326
    }
3327

    
3328
    subtitle_disable = 0;
3329
    av_freep(&subtitle_codec_name);
3330
    subtitle_stream_copy = 0;
3331
}
3332

    
3333
static void opt_new_audio_stream(void)
3334
{
3335
    AVFormatContext *oc;
3336
    if (nb_output_files <= 0) {
3337
        fprintf(stderr, "At least one output file must be specified\n");
3338
        av_exit(1);
3339
    }
3340
    oc = output_files[nb_output_files - 1];
3341
    new_audio_stream(oc);
3342
}
3343

    
3344
static void opt_new_video_stream(void)
3345
{
3346
    AVFormatContext *oc;
3347
    if (nb_output_files <= 0) {
3348
        fprintf(stderr, "At least one output file must be specified\n");
3349
        av_exit(1);
3350
    }
3351
    oc = output_files[nb_output_files - 1];
3352
    new_video_stream(oc);
3353
}
3354

    
3355
static void opt_new_subtitle_stream(void)
3356
{
3357
    AVFormatContext *oc;
3358
    if (nb_output_files <= 0) {
3359
        fprintf(stderr, "At least one output file must be specified\n");
3360
        av_exit(1);
3361
    }
3362
    oc = output_files[nb_output_files - 1];
3363
    new_subtitle_stream(oc);
3364
}
3365

    
3366
static void opt_output_file(const char *filename)
3367
{
3368
    AVFormatContext *oc;
3369
    int use_video, use_audio, use_subtitle;
3370
    int input_has_video, input_has_audio, input_has_subtitle;
3371
    AVFormatParameters params, *ap = &params;
3372
    AVOutputFormat *file_oformat;
3373

    
3374
    if (!strcmp(filename, "-"))
3375
        filename = "pipe:";
3376

    
3377
    oc = avformat_alloc_context();
3378
    if (!oc) {
3379
        print_error(filename, AVERROR(ENOMEM));
3380
        av_exit(1);
3381
    }
3382

    
3383
    if (last_asked_format) {
3384
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3385
        if (!file_oformat) {
3386
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3387
            av_exit(1);
3388
        }
3389
        last_asked_format = NULL;
3390
    } else {
3391
        file_oformat = av_guess_format(NULL, filename, NULL);
3392
        if (!file_oformat) {
3393
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3394
                    filename);
3395
            av_exit(1);
3396
        }
3397
    }
3398

    
3399
    oc->oformat = file_oformat;
3400
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3401

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

    
3416
        /* disable if no corresponding type found and at least one
3417
           input file */
3418
        if (nb_input_files > 0) {
3419
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3420
                                         &input_has_subtitle);
3421
            if (!input_has_video)
3422
                use_video = 0;
3423
            if (!input_has_audio)
3424
                use_audio = 0;
3425
            if (!input_has_subtitle)
3426
                use_subtitle = 0;
3427
        }
3428

    
3429
        /* manual disable */
3430
        if (audio_disable) {
3431
            use_audio = 0;
3432
        }
3433
        if (video_disable) {
3434
            use_video = 0;
3435
        }
3436
        if (subtitle_disable) {
3437
            use_subtitle = 0;
3438
        }
3439

    
3440
        if (use_video) {
3441
            new_video_stream(oc);
3442
        }
3443

    
3444
        if (use_audio) {
3445
            new_audio_stream(oc);
3446
        }
3447

    
3448
        if (use_subtitle) {
3449
            new_subtitle_stream(oc);
3450
        }
3451

    
3452
        oc->timestamp = rec_timestamp;
3453

    
3454
        for(; metadata_count>0; metadata_count--){
3455
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3456
                                           metadata[metadata_count-1].value);
3457
        }
3458
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3459
    }
3460

    
3461
    output_files[nb_output_files++] = oc;
3462

    
3463
    /* check filename in case of an image number is expected */
3464
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3465
        if (!av_filename_number_test(oc->filename)) {
3466
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3467
            av_exit(1);
3468
        }
3469
    }
3470

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

    
3493
        /* open the file */
3494
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3495
            fprintf(stderr, "Could not open '%s'\n", filename);
3496
            av_exit(1);
3497
        }
3498
    }
3499

    
3500
    memset(ap, 0, sizeof(*ap));
3501
    if (av_set_parameters(oc, ap) < 0) {
3502
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3503
                oc->filename);
3504
        av_exit(1);
3505
    }
3506

    
3507
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3508
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3509
    oc->loop_output = loop_output;
3510
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3511

    
3512
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3513
}
3514

    
3515
/* same option as mencoder */
3516
static void opt_pass(const char *pass_str)
3517
{
3518
    int pass;
3519
    pass = atoi(pass_str);
3520
    if (pass != 1 && pass != 2) {
3521
        fprintf(stderr, "pass number can be only 1 or 2\n");
3522
        av_exit(1);
3523
    }
3524
    do_pass = pass;
3525
}
3526

    
3527
static int64_t getutime(void)
3528
{
3529
#if HAVE_GETRUSAGE
3530
    struct rusage rusage;
3531

    
3532
    getrusage(RUSAGE_SELF, &rusage);
3533
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3534
#elif HAVE_GETPROCESSTIMES
3535
    HANDLE proc;
3536
    FILETIME c, e, k, u;
3537
    proc = GetCurrentProcess();
3538
    GetProcessTimes(proc, &c, &e, &k, &u);
3539
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3540
#else
3541
    return av_gettime();
3542
#endif
3543
}
3544

    
3545
static int64_t getmaxrss(void)
3546
{
3547
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3548
    struct rusage rusage;
3549
    getrusage(RUSAGE_SELF, &rusage);
3550
    return (int64_t)rusage.ru_maxrss * 1024;
3551
#elif HAVE_GETPROCESSMEMORYINFO
3552
    HANDLE proc;
3553
    PROCESS_MEMORY_COUNTERS memcounters;
3554
    proc = GetCurrentProcess();
3555
    memcounters.cb = sizeof(memcounters);
3556
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3557
    return memcounters.PeakPagefileUsage;
3558
#else
3559
    return 0;
3560
#endif
3561
}
3562

    
3563
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3564
{
3565
    int i;
3566
    const char *p = str;
3567
    for(i = 0;; i++) {
3568
        dest[i] = atoi(p);
3569
        if(i == 63)
3570
            break;
3571
        p = strchr(p, ',');
3572
        if(!p) {
3573
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3574
            av_exit(1);
3575
        }
3576
        p++;
3577
    }
3578
}
3579

    
3580
static void opt_inter_matrix(const char *arg)
3581
{
3582
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3583
    parse_matrix_coeffs(inter_matrix, arg);
3584
}
3585

    
3586
static void opt_intra_matrix(const char *arg)
3587
{
3588
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3589
    parse_matrix_coeffs(intra_matrix, arg);
3590
}
3591

    
3592
/**
3593
 * Trivial log callback.
3594
 * Only suitable for show_help and similar since it lacks prefix handling.
3595
 */
3596
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3597
{
3598
    vfprintf(stdout, fmt, vl);
3599
}
3600

    
3601
static void show_usage(void)
3602
{
3603
    printf("Hyper fast Audio and Video encoder\n");
3604
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3605
    printf("\n");
3606
}
3607

    
3608
static void show_help(void)
3609
{
3610
    av_log_set_callback(log_callback_help);
3611
    show_usage();
3612
    show_help_options(options, "Main options:\n",
3613
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3614
    show_help_options(options, "\nAdvanced options:\n",
3615
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3616
                      OPT_EXPERT);
3617
    show_help_options(options, "\nVideo options:\n",
3618
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3619
                      OPT_VIDEO);
3620
    show_help_options(options, "\nAdvanced Video options:\n",
3621
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3622
                      OPT_VIDEO | OPT_EXPERT);
3623
    show_help_options(options, "\nAudio options:\n",
3624
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3625
                      OPT_AUDIO);
3626
    show_help_options(options, "\nAdvanced Audio options:\n",
3627
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3628
                      OPT_AUDIO | OPT_EXPERT);
3629
    show_help_options(options, "\nSubtitle options:\n",
3630
                      OPT_SUBTITLE | OPT_GRAB,
3631
                      OPT_SUBTITLE);
3632
    show_help_options(options, "\nAudio/Video grab options:\n",
3633
                      OPT_GRAB,
3634
                      OPT_GRAB);
3635
    printf("\n");
3636
    av_opt_show(avcodec_opts[0], NULL);
3637
    printf("\n");
3638
    av_opt_show(avformat_opts, NULL);
3639
    printf("\n");
3640
    av_opt_show(sws_opts, NULL);
3641
}
3642

    
3643
static void opt_target(const char *arg)
3644
{
3645
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3646
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3647

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

    
3692
    if(norm == UNKNOWN) {
3693
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3694
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3695
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3696
        av_exit(1);
3697
    }
3698

    
3699
    if(!strcmp(arg, "vcd")) {
3700

    
3701
        opt_video_codec("mpeg1video");
3702
        opt_audio_codec("mp2");
3703
        opt_format("vcd");
3704

    
3705
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3706
        opt_frame_rate(NULL, frame_rates[norm]);
3707
        opt_default("g", norm == PAL ? "15" : "18");
3708

    
3709
        opt_default("b", "1150000");
3710
        opt_default("maxrate", "1150000");
3711
        opt_default("minrate", "1150000");
3712
        opt_default("bufsize", "327680"); // 40*1024*8;
3713

    
3714
        opt_default("ab", "224000");
3715
        audio_sample_rate = 44100;
3716
        audio_channels = 2;
3717

    
3718
        opt_default("packetsize", "2324");
3719
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3720

    
3721
        /* We have to offset the PTS, so that it is consistent with the SCR.
3722
           SCR starts at 36000, but the first two packs contain only padding
3723
           and the first pack from the other stream, respectively, may also have
3724
           been written before.
3725
           So the real data starts at SCR 36000+3*1200. */
3726
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3727
    } else if(!strcmp(arg, "svcd")) {
3728

    
3729
        opt_video_codec("mpeg2video");
3730
        opt_audio_codec("mp2");
3731
        opt_format("svcd");
3732

    
3733
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3734
        opt_frame_rate(NULL, frame_rates[norm]);
3735
        opt_default("g", norm == PAL ? "15" : "18");
3736

    
3737
        opt_default("b", "2040000");
3738
        opt_default("maxrate", "2516000");
3739
        opt_default("minrate", "0"); //1145000;
3740
        opt_default("bufsize", "1835008"); //224*1024*8;
3741
        opt_default("flags", "+scan_offset");
3742

    
3743

    
3744
        opt_default("ab", "224000");
3745
        audio_sample_rate = 44100;
3746

    
3747
        opt_default("packetsize", "2324");
3748

    
3749
    } else if(!strcmp(arg, "dvd")) {
3750

    
3751
        opt_video_codec("mpeg2video");
3752
        opt_audio_codec("ac3");
3753
        opt_format("dvd");
3754

    
3755
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3756
        opt_frame_rate(NULL, frame_rates[norm]);
3757
        opt_default("g", norm == PAL ? "15" : "18");
3758

    
3759
        opt_default("b", "6000000");
3760
        opt_default("maxrate", "9000000");
3761
        opt_default("minrate", "0"); //1500000;
3762
        opt_default("bufsize", "1835008"); //224*1024*8;
3763

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

    
3767
        opt_default("ab", "448000");
3768
        audio_sample_rate = 48000;
3769

    
3770
    } else if(!strncmp(arg, "dv", 2)) {
3771

    
3772
        opt_format("dv");
3773

    
3774
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3775
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3776
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3777
        opt_frame_rate(NULL, frame_rates[norm]);
3778

    
3779
        audio_sample_rate = 48000;
3780
        audio_channels = 2;
3781

    
3782
    } else {
3783
        fprintf(stderr, "Unknown target: %s\n", arg);
3784
        av_exit(1);
3785
    }
3786
}
3787

    
3788
static void opt_vstats_file (const char *arg)
3789
{
3790
    av_free (vstats_filename);
3791
    vstats_filename=av_strdup (arg);
3792
}
3793

    
3794
static void opt_vstats (void)
3795
{
3796
    char filename[40];
3797
    time_t today2 = time(NULL);
3798
    struct tm *today = localtime(&today2);
3799

    
3800
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3801
             today->tm_sec);
3802
    opt_vstats_file(filename);
3803
}
3804

    
3805
static int opt_bsf(const char *opt, const char *arg)
3806
{
3807
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3808
    AVBitStreamFilterContext **bsfp;
3809

    
3810
    if(!bsfc){
3811
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3812
        av_exit(1);
3813
    }
3814

    
3815
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3816
          *opt == 'a' ? &audio_bitstream_filters :
3817
                        &subtitle_bitstream_filters;
3818
    while(*bsfp)
3819
        bsfp= &(*bsfp)->next;
3820

    
3821
    *bsfp= bsfc;
3822

    
3823
    return 0;
3824
}
3825

    
3826
static int opt_preset(const char *opt, const char *arg)
3827
{
3828
    FILE *f=NULL;
3829
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3830
    int i;
3831
    const char *base[2]= { getenv("HOME"),
3832
                           FFMPEG_DATADIR,
3833
                         };
3834

    
3835
    if (*opt != 'f') {
3836
        for(i=!base[0]; i<2 && !f; i++){
3837
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3838
            f= fopen(filename, "r");
3839
            if(!f){
3840
                char *codec_name= *opt == 'v' ? video_codec_name :
3841
                                  *opt == 'a' ? audio_codec_name :
3842
                                                subtitle_codec_name;
3843
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3844
                f= fopen(filename, "r");
3845
            }
3846
        }
3847
    } else {
3848
        av_strlcpy(filename, arg, sizeof(filename));
3849
        f= fopen(filename, "r");
3850
    }
3851

    
3852
    if(!f){
3853
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3854
        av_exit(1);
3855
    }
3856

    
3857
    while(!feof(f)){
3858
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3859
        if(line[0] == '#' && !e)
3860
            continue;
3861
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3862
        if(e){
3863
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3864
            av_exit(1);
3865
        }
3866
        if(!strcmp(tmp, "acodec")){
3867
            opt_audio_codec(tmp2);
3868
        }else if(!strcmp(tmp, "vcodec")){
3869
            opt_video_codec(tmp2);
3870
        }else if(!strcmp(tmp, "scodec")){
3871
            opt_subtitle_codec(tmp2);
3872
        }else if(opt_default(tmp, tmp2) < 0){
3873
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3874
            av_exit(1);
3875
        }
3876
    }
3877

    
3878
    fclose(f);
3879

    
3880
    return 0;
3881
}
3882

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

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

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

    
3980
    /* subtitle options */
3981
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3982
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3983
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3984
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3985
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3986

    
3987
    /* grab options */
3988
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3989
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3990
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3991

    
3992
    /* muxer options */
3993
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3994
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3995

    
3996
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3997
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3998
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3999

    
4000
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4001
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4002
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4003
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4004

    
4005
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4006
    { NULL, },
4007
};
4008

    
4009
int main(int argc, char **argv)
4010
{
4011
    int i;
4012
    int64_t ti;
4013

    
4014
    avcodec_register_all();
4015
    avdevice_register_all();
4016
    av_register_all();
4017

    
4018
#if HAVE_ISATTY
4019
    if(isatty(STDIN_FILENO))
4020
        url_set_interrupt_cb(decode_interrupt_cb);
4021
#endif
4022

    
4023
    for(i=0; i<CODEC_TYPE_NB; i++){
4024
        avcodec_opts[i]= avcodec_alloc_context2(i);
4025
    }
4026
    avformat_opts = avformat_alloc_context();
4027
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4028

    
4029
    show_banner();
4030

    
4031
    /* parse options */
4032
    parse_options(argc, argv, options, opt_output_file);
4033

    
4034
    if(nb_output_files <= 0 && nb_input_files == 0) {
4035
        show_usage();
4036
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4037
        av_exit(1);
4038
    }
4039

    
4040
    /* file converter / grab */
4041
    if (nb_output_files <= 0) {
4042
        fprintf(stderr, "At least one output file must be specified\n");
4043
        av_exit(1);
4044
    }
4045

    
4046
    if (nb_input_files == 0) {
4047
        fprintf(stderr, "At least one input file must be specified\n");
4048
        av_exit(1);
4049
    }
4050

    
4051
    ti = getutime();
4052
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4053
                  stream_maps, nb_stream_maps) < 0)
4054
        av_exit(1);
4055
    ti = getutime() - ti;
4056
    if (do_benchmark) {
4057
        int maxrss = getmaxrss() / 1024;
4058
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4059
    }
4060

    
4061
    return av_exit(0);
4062
}