Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ ac61f59a

History | View | Annotate | Download (148 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 "libavutil/libm.h"
44
#include "libavformat/os_support.h"
45

    
46
#if HAVE_SYS_RESOURCE_H
47
#include <sys/types.h>
48
#include <sys/time.h>
49
#include <sys/resource.h>
50
#elif HAVE_GETPROCESSTIMES
51
#include <windows.h>
52
#endif
53
#if HAVE_GETPROCESSMEMORYINFO
54
#include <windows.h>
55
#include <psapi.h>
56
#endif
57

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

    
62
#if HAVE_TERMIOS_H
63
#include <fcntl.h>
64
#include <sys/ioctl.h>
65
#include <sys/time.h>
66
#include <termios.h>
67
#elif HAVE_CONIO_H
68
#include <conio.h>
69
#endif
70
#include <time.h>
71

    
72
#include "cmdutils.h"
73

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

    
77
const char program_name[] = "FFmpeg";
78
const int program_birth_year = 2000;
79

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

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

    
94
static const OptionDef options[];
95

    
96
#define MAX_FILES 100
97

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

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

    
111
static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
112
static int nb_stream_maps;
113

    
114
static AVMetaDataMap meta_data_maps[MAX_FILES];
115
static int nb_meta_data_maps;
116

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

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

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

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

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

    
197
static int rate_emu = 0;
198

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

    
202
static int audio_volume = 256;
203

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

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

    
221
static unsigned int sws_flags = SWS_BICUBIC;
222

    
223
static int64_t timer_start;
224

    
225
static uint8_t *audio_buf;
226
static uint8_t *audio_out;
227
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
228

    
229
static short *samples;
230

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

    
236
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
237

    
238
struct AVInputStream;
239

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

    
260
    /* full frame size of first frame */
261
    int original_height;
262
    int original_width;
263

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

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

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

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

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

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

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

    
317
#if HAVE_TERMIOS_H
318

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

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

    
330
static volatile int received_sigterm = 0;
331

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

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

    
344
    tcgetattr (0, &tty);
345
    oldtty = tty;
346
    atexit(term_exit);
347

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

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

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

    
367
#if CONFIG_BEOS_NETSERVER
368
    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
369
#endif
370
}
371

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

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

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

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

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

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

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

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

    
442
    av_free(opt_names);
443

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

    
448
    av_free(video_standard);
449

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

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

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

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

    
475
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
476
{
477
    if(codec && codec->sample_fmts){
478
        const enum SampleFormat *p= codec->sample_fmts;
479
        for(; *p!=-1; p++){
480
            if(*p == st->codec->sample_fmt)
481
                break;
482
        }
483
        if(*p == -1)
484
            st->codec->sample_fmt = codec->sample_fmts[0];
485
    }
486
}
487

    
488
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
489
{
490
    if(codec && codec->pix_fmts){
491
        const enum PixelFormat *p= codec->pix_fmts;
492
        for(; *p!=-1; p++){
493
            if(*p == st->codec->pix_fmt)
494
                break;
495
        }
496
        if(*p == -1
497
           && !(   st->codec->codec_id==CODEC_ID_MJPEG
498
                && st->codec->strict_std_compliance <= FF_COMPLIANCE_INOFFICIAL
499
                && (   st->codec->pix_fmt == PIX_FMT_YUV420P
500
                    || st->codec->pix_fmt == PIX_FMT_YUV422P)))
501
            st->codec->pix_fmt = codec->pix_fmts[0];
502
    }
503
}
504

    
505
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
506
{
507
    int i, err;
508
    AVFormatContext *ic;
509
    int nopts = 0;
510

    
511
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
512
    if (err < 0)
513
        return err;
514
    /* copy stream format */
515
    s->nb_streams = ic->nb_streams;
516
    for(i=0;i<ic->nb_streams;i++) {
517
        AVStream *st;
518
        AVCodec *codec;
519

    
520
        // FIXME: a more elegant solution is needed
521
        st = av_mallocz(sizeof(AVStream));
522
        memcpy(st, ic->streams[i], sizeof(AVStream));
523
        st->codec = avcodec_alloc_context();
524
        if (!st->codec) {
525
            print_error(filename, AVERROR(ENOMEM));
526
            av_exit(1);
527
        }
528
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
529
        s->streams[i] = st;
530

    
531
        codec = avcodec_find_encoder(st->codec->codec_id);
532
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
533
            if (audio_stream_copy) {
534
                st->stream_copy = 1;
535
            } else
536
                choose_sample_fmt(st, codec);
537
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
538
            if (video_stream_copy) {
539
                st->stream_copy = 1;
540
            } else
541
                choose_pixel_fmt(st, codec);
542
        }
543

    
544
        if(!st->codec->thread_count)
545
            st->codec->thread_count = 1;
546
        if(st->codec->thread_count>1)
547
            avcodec_thread_init(st->codec, st->codec->thread_count);
548

    
549
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
550
            nopts = 1;
551
    }
552

    
553
    if (!nopts)
554
        s->timestamp = av_gettime();
555

    
556
    av_close_input_file(ic);
557
    return 0;
558
}
559

    
560
static double
561
get_sync_ipts(const AVOutputStream *ost)
562
{
563
    const AVInputStream *ist = ost->sync_ist;
564
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
565
}
566

    
567
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
568
    int ret;
569

    
570
    while(bsfc){
571
        AVPacket new_pkt= *pkt;
572
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
573
                                          &new_pkt.data, &new_pkt.size,
574
                                          pkt->data, pkt->size,
575
                                          pkt->flags & AV_PKT_FLAG_KEY);
576
        if(a>0){
577
            av_free_packet(pkt);
578
            new_pkt.destruct= av_destruct_packet;
579
        } else if(a<0){
580
            fprintf(stderr, "%s failed for stream %d, codec %s",
581
                    bsfc->filter->name, pkt->stream_index,
582
                    avctx->codec ? avctx->codec->name : "copy");
583
            print_error("", a);
584
            if (exit_on_error)
585
                av_exit(1);
586
        }
587
        *pkt= new_pkt;
588

    
589
        bsfc= bsfc->next;
590
    }
591

    
592
    ret= av_interleaved_write_frame(s, pkt);
593
    if(ret < 0){
594
        print_error("av_interleaved_write_frame()", ret);
595
        av_exit(1);
596
    }
597
}
598

    
599
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
600

    
601
static void do_audio_out(AVFormatContext *s,
602
                         AVOutputStream *ost,
603
                         AVInputStream *ist,
604
                         unsigned char *buf, int size)
605
{
606
    uint8_t *buftmp;
607
    int64_t audio_out_size, audio_buf_size;
608
    int64_t allocated_for_size= size;
609

    
610
    int size_out, frame_bytes, ret;
611
    AVCodecContext *enc= ost->st->codec;
612
    AVCodecContext *dec= ist->st->codec;
613
    int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
614
    int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
615
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
616

    
617
need_realloc:
618
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
619
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
620
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
621
    audio_buf_size*= osize*enc->channels;
622

    
623
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
624
    if(coded_bps > 8*osize)
625
        audio_out_size= audio_out_size * coded_bps / (8*osize);
626
    audio_out_size += FF_MIN_BUFFER_SIZE;
627

    
628
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
629
        fprintf(stderr, "Buffer sizes too large\n");
630
        av_exit(1);
631
    }
632

    
633
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
634
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
635
    if (!audio_buf || !audio_out){
636
        fprintf(stderr, "Out of memory in do_audio_out\n");
637
        av_exit(1);
638
    }
639

    
640
    if (enc->channels != dec->channels)
641
        ost->audio_resample = 1;
642

    
643
    if (ost->audio_resample && !ost->resample) {
644
        if (dec->sample_fmt != SAMPLE_FMT_S16)
645
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
646
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
647
                                               enc->sample_rate, dec->sample_rate,
648
                                               enc->sample_fmt,  dec->sample_fmt,
649
                                               16, 10, 0, 0.8);
650
        if (!ost->resample) {
651
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
652
                    dec->channels, dec->sample_rate,
653
                    enc->channels, enc->sample_rate);
654
            av_exit(1);
655
        }
656
    }
657

    
658
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
659
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
660
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
661
        if (ost->reformat_ctx)
662
            av_audio_convert_free(ost->reformat_ctx);
663
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
664
                                                   dec->sample_fmt, 1, NULL, 0);
665
        if (!ost->reformat_ctx) {
666
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
667
                avcodec_get_sample_fmt_name(dec->sample_fmt),
668
                avcodec_get_sample_fmt_name(enc->sample_fmt));
669
            av_exit(1);
670
        }
671
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
672
    }
673

    
674
    if(audio_sync_method){
675
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
676
                - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
677
        double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
678
        int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
679

    
680
        //FIXME resample delay
681
        if(fabs(delta) > 50){
682
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
683
                if(byte_delta < 0){
684
                    byte_delta= FFMAX(byte_delta, -size);
685
                    size += byte_delta;
686
                    buf  -= byte_delta;
687
                    if(verbose > 2)
688
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
689
                    if(!size)
690
                        return;
691
                    ist->is_start=0;
692
                }else{
693
                    static uint8_t *input_tmp= NULL;
694
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
695

    
696
                    if(byte_delta > allocated_for_size - size){
697
                        allocated_for_size= byte_delta + (int64_t)size;
698
                        goto need_realloc;
699
                    }
700
                    ist->is_start=0;
701

    
702
                    memset(input_tmp, 0, byte_delta);
703
                    memcpy(input_tmp + byte_delta, buf, size);
704
                    buf= input_tmp;
705
                    size += byte_delta;
706
                    if(verbose > 2)
707
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
708
                }
709
            }else if(audio_sync_method>1){
710
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
711
                assert(ost->audio_resample);
712
                if(verbose > 2)
713
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
714
//                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));
715
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
716
            }
717
        }
718
    }else
719
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
720
                        - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
721

    
722
    if (ost->audio_resample) {
723
        buftmp = audio_buf;
724
        size_out = audio_resample(ost->resample,
725
                                  (short *)buftmp, (short *)buf,
726
                                  size / (ist->st->codec->channels * isize));
727
        size_out = size_out * enc->channels * osize;
728
    } else {
729
        buftmp = buf;
730
        size_out = size;
731
    }
732

    
733
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
734
        const void *ibuf[6]= {buftmp};
735
        void *obuf[6]= {audio_buf};
736
        int istride[6]= {isize};
737
        int ostride[6]= {osize};
738
        int len= size_out/istride[0];
739
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
740
            printf("av_audio_convert() failed\n");
741
            if (exit_on_error)
742
                av_exit(1);
743
            return;
744
        }
745
        buftmp = audio_buf;
746
        size_out = len*osize;
747
    }
748

    
749
    /* now encode as many frames as possible */
750
    if (enc->frame_size > 1) {
751
        /* output resampled raw samples */
752
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
753
            fprintf(stderr, "av_fifo_realloc2() failed\n");
754
            av_exit(1);
755
        }
756
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
757

    
758
        frame_bytes = enc->frame_size * osize * enc->channels;
759

    
760
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
761
            AVPacket pkt;
762
            av_init_packet(&pkt);
763

    
764
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
765

    
766
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
767

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

    
783
            ost->sync_opts += enc->frame_size;
784
        }
785
    } else {
786
        AVPacket pkt;
787
        av_init_packet(&pkt);
788

    
789
        ost->sync_opts += size_out / (osize * enc->channels);
790

    
791
        /* output a pcm frame */
792
        /* determine the size of the coded buffer */
793
        size_out /= osize;
794
        if (coded_bps)
795
            size_out = size_out*coded_bps/8;
796

    
797
        if(size_out > audio_out_size){
798
            fprintf(stderr, "Internal error, buffer size too small\n");
799
            av_exit(1);
800
        }
801

    
802
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
803
        ret = avcodec_encode_audio(enc, audio_out, size_out,
804
                                   (short *)buftmp);
805
        if (ret < 0) {
806
            fprintf(stderr, "Audio encoding failed\n");
807
            av_exit(1);
808
        }
809
        audio_size += ret;
810
        pkt.stream_index= ost->index;
811
        pkt.data= audio_out;
812
        pkt.size= ret;
813
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
814
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
815
        pkt.flags |= AV_PKT_FLAG_KEY;
816
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
817
    }
818
}
819

    
820
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
821
{
822
    AVCodecContext *dec;
823
    AVPicture *picture2;
824
    AVPicture picture_tmp;
825
    uint8_t *buf = 0;
826

    
827
    dec = ist->st->codec;
828

    
829
    /* deinterlace : must be done before any resize */
830
    if (do_deinterlace) {
831
        int size;
832

    
833
        /* create temporary picture */
834
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
835
        buf = av_malloc(size);
836
        if (!buf)
837
            return;
838

    
839
        picture2 = &picture_tmp;
840
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
841

    
842
        if(avpicture_deinterlace(picture2, picture,
843
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
844
            /* if error, do not deinterlace */
845
            fprintf(stderr, "Deinterlacing failed\n");
846
            av_free(buf);
847
            buf = NULL;
848
            picture2 = picture;
849
        }
850
    } else {
851
        picture2 = picture;
852
    }
853

    
854
    if (picture != picture2)
855
        *picture = *picture2;
856
    *bufp = buf;
857
}
858

    
859
/* we begin to correct av delay at this threshold */
860
#define AV_DELAY_MAX 0.100
861

    
862
static void do_subtitle_out(AVFormatContext *s,
863
                            AVOutputStream *ost,
864
                            AVInputStream *ist,
865
                            AVSubtitle *sub,
866
                            int64_t pts)
867
{
868
    static uint8_t *subtitle_out = NULL;
869
    int subtitle_out_max_size = 1024 * 1024;
870
    int subtitle_out_size, nb, i;
871
    AVCodecContext *enc;
872
    AVPacket pkt;
873

    
874
    if (pts == AV_NOPTS_VALUE) {
875
        fprintf(stderr, "Subtitle packets must have a pts\n");
876
        if (exit_on_error)
877
            av_exit(1);
878
        return;
879
    }
880

    
881
    enc = ost->st->codec;
882

    
883
    if (!subtitle_out) {
884
        subtitle_out = av_malloc(subtitle_out_max_size);
885
    }
886

    
887
    /* Note: DVB subtitle need one packet to draw them and one other
888
       packet to clear them */
889
    /* XXX: signal it in the codec context ? */
890
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
891
        nb = 2;
892
    else
893
        nb = 1;
894

    
895
    for(i = 0; i < nb; i++) {
896
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
897
        // start_display_time is required to be 0
898
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
899
        sub->end_display_time -= sub->start_display_time;
900
        sub->start_display_time = 0;
901
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
902
                                                    subtitle_out_max_size, sub);
903
        if (subtitle_out_size < 0) {
904
            fprintf(stderr, "Subtitle encoding failed\n");
905
            av_exit(1);
906
        }
907

    
908
        av_init_packet(&pkt);
909
        pkt.stream_index = ost->index;
910
        pkt.data = subtitle_out;
911
        pkt.size = subtitle_out_size;
912
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
913
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
914
            /* XXX: the pts correction is handled here. Maybe handling
915
               it in the codec would be better */
916
            if (i == 0)
917
                pkt.pts += 90 * sub->start_display_time;
918
            else
919
                pkt.pts += 90 * sub->end_display_time;
920
        }
921
        write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
922
    }
923
}
924

    
925
static int bit_buffer_size= 1024*256;
926
static uint8_t *bit_buffer= NULL;
927

    
928
static void do_video_out(AVFormatContext *s,
929
                         AVOutputStream *ost,
930
                         AVInputStream *ist,
931
                         AVFrame *in_picture,
932
                         int *frame_size)
933
{
934
    int nb_frames, i, ret;
935
    int64_t topBand, bottomBand, leftBand, rightBand;
936
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
937
    AVFrame picture_crop_temp, picture_pad_temp;
938
    AVCodecContext *enc, *dec;
939
    double sync_ipts;
940

    
941
    avcodec_get_frame_defaults(&picture_crop_temp);
942
    avcodec_get_frame_defaults(&picture_pad_temp);
943

    
944
    enc = ost->st->codec;
945
    dec = ist->st->codec;
946

    
947
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
948

    
949
    /* by default, we output a single frame */
950
    nb_frames = 1;
951

    
952
    *frame_size = 0;
953

    
954
    if(video_sync_method){
955
        double vdelta = sync_ipts - ost->sync_opts;
956
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
957
        if (vdelta < -1.1)
958
            nb_frames = 0;
959
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
960
            if(vdelta<=-0.6){
961
                nb_frames=0;
962
            }else if(vdelta>0.6)
963
            ost->sync_opts= lrintf(sync_ipts);
964
        }else if (vdelta > 1.1)
965
            nb_frames = lrintf(vdelta);
966
//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);
967
        if (nb_frames == 0){
968
            ++nb_frames_drop;
969
            if (verbose>2)
970
                fprintf(stderr, "*** drop!\n");
971
        }else if (nb_frames > 1) {
972
            nb_frames_dup += nb_frames - 1;
973
            if (verbose>2)
974
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
975
        }
976
    }else
977
        ost->sync_opts= lrintf(sync_ipts);
978

    
979
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
980
    if (nb_frames <= 0)
981
        return;
982

    
983
    if (ost->video_crop) {
984
        if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
985
            fprintf(stderr, "error cropping picture\n");
986
            if (exit_on_error)
987
                av_exit(1);
988
            return;
989
        }
990
        formatted_picture = &picture_crop_temp;
991
    } else {
992
        formatted_picture = in_picture;
993
    }
994

    
995
    final_picture = formatted_picture;
996
    padding_src = formatted_picture;
997
    resampling_dst = &ost->pict_tmp;
998
    if (ost->video_pad) {
999
        final_picture = &ost->pict_tmp;
1000
        if (ost->video_resample) {
1001
            if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
1002
                fprintf(stderr, "error padding picture\n");
1003
                if (exit_on_error)
1004
                    av_exit(1);
1005
                return;
1006
            }
1007
            resampling_dst = &picture_pad_temp;
1008
        }
1009
    }
1010

    
1011
    if(    (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
1012
        || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
1013
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1014

    
1015
        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));
1016
        if(!ost->video_resample)
1017
            av_exit(1);
1018
    }
1019

    
1020
    if (ost->video_resample) {
1021
        padding_src = NULL;
1022
        final_picture = &ost->pict_tmp;
1023
        if(  (ost->resample_height != (ist->st->codec->height - (ost->topBand  + ost->bottomBand)))
1024
          || (ost->resample_width  != (ist->st->codec->width  - (ost->leftBand + ost->rightBand)))
1025
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1026

    
1027
            /* keep bands proportional to the frame size */
1028
            topBand    = ((int64_t)ist->st->codec->height * ost->original_topBand    / ost->original_height) & ~1;
1029
            bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
1030
            leftBand   = ((int64_t)ist->st->codec->width  * ost->original_leftBand   / ost->original_width)  & ~1;
1031
            rightBand  = ((int64_t)ist->st->codec->width  * ost->original_rightBand  / ost->original_width)  & ~1;
1032

    
1033
            /* sanity check to ensure no bad band sizes sneak in */
1034
            assert(topBand    <= INT_MAX && topBand    >= 0);
1035
            assert(bottomBand <= INT_MAX && bottomBand >= 0);
1036
            assert(leftBand   <= INT_MAX && leftBand   >= 0);
1037
            assert(rightBand  <= INT_MAX && rightBand  >= 0);
1038

    
1039
            ost->topBand    = topBand;
1040
            ost->bottomBand = bottomBand;
1041
            ost->leftBand   = leftBand;
1042
            ost->rightBand  = rightBand;
1043

    
1044
            ost->resample_height = ist->st->codec->height - (ost->topBand  + ost->bottomBand);
1045
            ost->resample_width  = ist->st->codec->width  - (ost->leftBand + ost->rightBand);
1046
            ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1047

    
1048
            /* initialize a new scaler context */
1049
            sws_freeContext(ost->img_resample_ctx);
1050
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1051
            ost->img_resample_ctx = sws_getContext(
1052
                ist->st->codec->width  - (ost->leftBand + ost->rightBand),
1053
                ist->st->codec->height - (ost->topBand  + ost->bottomBand),
1054
                ist->st->codec->pix_fmt,
1055
                ost->st->codec->width  - (ost->padleft  + ost->padright),
1056
                ost->st->codec->height - (ost->padtop   + ost->padbottom),
1057
                ost->st->codec->pix_fmt,
1058
                sws_flags, NULL, NULL, NULL);
1059
            if (ost->img_resample_ctx == NULL) {
1060
                fprintf(stderr, "Cannot get resampling context\n");
1061
                av_exit(1);
1062
            }
1063
        }
1064
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1065
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1066
    }
1067

    
1068
    if (ost->video_pad) {
1069
        av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1070
                enc->height, enc->width, enc->pix_fmt,
1071
                ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1072
    }
1073

    
1074
    /* duplicates frame if needed */
1075
    for(i=0;i<nb_frames;i++) {
1076
        AVPacket pkt;
1077
        av_init_packet(&pkt);
1078
        pkt.stream_index= ost->index;
1079

    
1080
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1081
            /* raw pictures are written as AVPicture structure to
1082
               avoid any copies. We support temorarily the older
1083
               method. */
1084
            AVFrame* old_frame = enc->coded_frame;
1085
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1086
            pkt.data= (uint8_t *)final_picture;
1087
            pkt.size=  sizeof(AVPicture);
1088
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1089
            pkt.flags |= AV_PKT_FLAG_KEY;
1090

    
1091
            write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1092
            enc->coded_frame = old_frame;
1093
        } else {
1094
            AVFrame big_picture;
1095

    
1096
            big_picture= *final_picture;
1097
            /* better than nothing: use input picture interlaced
1098
               settings */
1099
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1100
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1101
                if(top_field_first == -1)
1102
                    big_picture.top_field_first = in_picture->top_field_first;
1103
                else
1104
                    big_picture.top_field_first = top_field_first;
1105
            }
1106

    
1107
            /* handles sameq here. This is not correct because it may
1108
               not be a global option */
1109
            if (same_quality) {
1110
                big_picture.quality = ist->st->quality;
1111
            }else
1112
                big_picture.quality = ost->st->quality;
1113
            if(!me_threshold)
1114
                big_picture.pict_type = 0;
1115
//            big_picture.pts = AV_NOPTS_VALUE;
1116
            big_picture.pts= ost->sync_opts;
1117
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1118
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1119
            ret = avcodec_encode_video(enc,
1120
                                       bit_buffer, bit_buffer_size,
1121
                                       &big_picture);
1122
            if (ret < 0) {
1123
                fprintf(stderr, "Video encoding failed\n");
1124
                av_exit(1);
1125
            }
1126

    
1127
            if(ret>0){
1128
                pkt.data= bit_buffer;
1129
                pkt.size= ret;
1130
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1131
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1132
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1133
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1134
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1135

    
1136
                if(enc->coded_frame->key_frame)
1137
                    pkt.flags |= AV_PKT_FLAG_KEY;
1138
                write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1139
                *frame_size = ret;
1140
                video_size += ret;
1141
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1142
                //        enc->frame_number-1, ret, enc->pict_type);
1143
                /* if two pass, output log */
1144
                if (ost->logfile && enc->stats_out) {
1145
                    fprintf(ost->logfile, "%s", enc->stats_out);
1146
                }
1147
            }
1148
        }
1149
        ost->sync_opts++;
1150
        ost->frame_number++;
1151
    }
1152
}
1153

    
1154
static double psnr(double d){
1155
    return -10.0*log(d)/log(10.0);
1156
}
1157

    
1158
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1159
                           int frame_size)
1160
{
1161
    AVCodecContext *enc;
1162
    int frame_number;
1163
    double ti1, bitrate, avg_bitrate;
1164

    
1165
    /* this is executed just the first time do_video_stats is called */
1166
    if (!vstats_file) {
1167
        vstats_file = fopen(vstats_filename, "w");
1168
        if (!vstats_file) {
1169
            perror("fopen");
1170
            av_exit(1);
1171
        }
1172
    }
1173

    
1174
    enc = ost->st->codec;
1175
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1176
        frame_number = ost->frame_number;
1177
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1178
        if (enc->flags&CODEC_FLAG_PSNR)
1179
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1180

    
1181
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1182
        /* compute pts value */
1183
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1184
        if (ti1 < 0.01)
1185
            ti1 = 0.01;
1186

    
1187
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1188
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1189
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1190
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1191
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1192
    }
1193
}
1194

    
1195
static void print_report(AVFormatContext **output_files,
1196
                         AVOutputStream **ost_table, int nb_ostreams,
1197
                         int is_last_report)
1198
{
1199
    char buf[1024];
1200
    AVOutputStream *ost;
1201
    AVFormatContext *oc;
1202
    int64_t total_size;
1203
    AVCodecContext *enc;
1204
    int frame_number, vid, i;
1205
    double bitrate, ti1, pts;
1206
    static int64_t last_time = -1;
1207
    static int qp_histogram[52];
1208

    
1209
    if (!is_last_report) {
1210
        int64_t cur_time;
1211
        /* display the report every 0.5 seconds */
1212
        cur_time = av_gettime();
1213
        if (last_time == -1) {
1214
            last_time = cur_time;
1215
            return;
1216
        }
1217
        if ((cur_time - last_time) < 500000)
1218
            return;
1219
        last_time = cur_time;
1220
    }
1221

    
1222

    
1223
    oc = output_files[0];
1224

    
1225
    total_size = url_fsize(oc->pb);
1226
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1227
        total_size= url_ftell(oc->pb);
1228

    
1229
    buf[0] = '\0';
1230
    ti1 = 1e10;
1231
    vid = 0;
1232
    for(i=0;i<nb_ostreams;i++) {
1233
        ost = ost_table[i];
1234
        enc = ost->st->codec;
1235
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1236
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1237
                     !ost->st->stream_copy ?
1238
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1239
        }
1240
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1241
            float t = (av_gettime()-timer_start) / 1000000.0;
1242

    
1243
            frame_number = ost->frame_number;
1244
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1245
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1246
                     !ost->st->stream_copy ?
1247
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1248
            if(is_last_report)
1249
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1250
            if(qp_hist){
1251
                int j;
1252
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1253
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1254
                    qp_histogram[qp]++;
1255
                for(j=0; j<32; j++)
1256
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1257
            }
1258
            if (enc->flags&CODEC_FLAG_PSNR){
1259
                int j;
1260
                double error, error_sum=0;
1261
                double scale, scale_sum=0;
1262
                char type[3]= {'Y','U','V'};
1263
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1264
                for(j=0; j<3; j++){
1265
                    if(is_last_report){
1266
                        error= enc->error[j];
1267
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1268
                    }else{
1269
                        error= enc->coded_frame->error[j];
1270
                        scale= enc->width*enc->height*255.0*255.0;
1271
                    }
1272
                    if(j) scale/=4;
1273
                    error_sum += error;
1274
                    scale_sum += scale;
1275
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1276
                }
1277
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1278
            }
1279
            vid = 1;
1280
        }
1281
        /* compute min output value */
1282
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1283
        if ((pts < ti1) && (pts > 0))
1284
            ti1 = pts;
1285
    }
1286
    if (ti1 < 0.01)
1287
        ti1 = 0.01;
1288

    
1289
    if (verbose || is_last_report) {
1290
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1291

    
1292
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1293
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1294
            (double)total_size / 1024, ti1, bitrate);
1295

    
1296
        if (nb_frames_dup || nb_frames_drop)
1297
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1298
                  nb_frames_dup, nb_frames_drop);
1299

    
1300
        if (verbose >= 0)
1301
            fprintf(stderr, "%s    \r", buf);
1302

    
1303
        fflush(stderr);
1304
    }
1305

    
1306
    if (is_last_report && verbose >= 0){
1307
        int64_t raw= audio_size + video_size + extra_size;
1308
        fprintf(stderr, "\n");
1309
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1310
                video_size/1024.0,
1311
                audio_size/1024.0,
1312
                extra_size/1024.0,
1313
                100.0*(total_size - raw)/raw
1314
        );
1315
    }
1316
}
1317

    
1318
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1319
static int output_packet(AVInputStream *ist, int ist_index,
1320
                         AVOutputStream **ost_table, int nb_ostreams,
1321
                         const AVPacket *pkt)
1322
{
1323
    AVFormatContext *os;
1324
    AVOutputStream *ost;
1325
    int ret, i;
1326
    int got_picture;
1327
    AVFrame picture;
1328
    void *buffer_to_free;
1329
    static unsigned int samples_size= 0;
1330
    AVSubtitle subtitle, *subtitle_to_free;
1331
    int got_subtitle;
1332
    AVPacket avpkt;
1333
    int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1334

    
1335
    if(ist->next_pts == AV_NOPTS_VALUE)
1336
        ist->next_pts= ist->pts;
1337

    
1338
    if (pkt == NULL) {
1339
        /* EOF handling */
1340
        av_init_packet(&avpkt);
1341
        avpkt.data = NULL;
1342
        avpkt.size = 0;
1343
        goto handle_eof;
1344
    } else {
1345
        avpkt = *pkt;
1346
    }
1347

    
1348
    if(pkt->dts != AV_NOPTS_VALUE)
1349
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1350

    
1351
    //while we have more to decode or while the decoder did output something on EOF
1352
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1353
        uint8_t *data_buf, *decoded_data_buf;
1354
        int data_size, decoded_data_size;
1355
    handle_eof:
1356
        ist->pts= ist->next_pts;
1357

    
1358
        if(avpkt.size && avpkt.size != pkt->size &&
1359
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1360
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1361
            ist->showed_multi_packet_warning=1;
1362
        }
1363

    
1364
        /* decode the packet if needed */
1365
        decoded_data_buf = NULL; /* fail safe */
1366
        decoded_data_size= 0;
1367
        data_buf  = avpkt.data;
1368
        data_size = avpkt.size;
1369
        subtitle_to_free = NULL;
1370
        if (ist->decoding_needed) {
1371
            switch(ist->st->codec->codec_type) {
1372
            case AVMEDIA_TYPE_AUDIO:{
1373
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1374
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1375
                    av_free(samples);
1376
                    samples= av_malloc(samples_size);
1377
                }
1378
                decoded_data_size= samples_size;
1379
                    /* XXX: could avoid copy if PCM 16 bits with same
1380
                       endianness as CPU */
1381
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1382
                                            &avpkt);
1383
                if (ret < 0)
1384
                    goto fail_decode;
1385
                avpkt.data += ret;
1386
                avpkt.size -= ret;
1387
                data_size   = ret;
1388
                /* Some bug in mpeg audio decoder gives */
1389
                /* decoded_data_size < 0, it seems they are overflows */
1390
                if (decoded_data_size <= 0) {
1391
                    /* no audio frame */
1392
                    continue;
1393
                }
1394
                decoded_data_buf = (uint8_t *)samples;
1395
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1396
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1397
                break;}
1398
            case AVMEDIA_TYPE_VIDEO:
1399
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1400
                    /* XXX: allocate picture correctly */
1401
                    avcodec_get_frame_defaults(&picture);
1402

    
1403
                    ret = avcodec_decode_video2(ist->st->codec,
1404
                                                &picture, &got_picture, &avpkt);
1405
                    ist->st->quality= picture.quality;
1406
                    if (ret < 0)
1407
                        goto fail_decode;
1408
                    if (!got_picture) {
1409
                        /* no picture yet */
1410
                        goto discard_packet;
1411
                    }
1412
                    if (ist->st->codec->time_base.num != 0) {
1413
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1414
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1415
                                          ist->st->codec->time_base.num * ticks) /
1416
                            ist->st->codec->time_base.den;
1417
                    }
1418
                    avpkt.size = 0;
1419
                    break;
1420
            case AVMEDIA_TYPE_SUBTITLE:
1421
                ret = avcodec_decode_subtitle2(ist->st->codec,
1422
                                               &subtitle, &got_subtitle, &avpkt);
1423
                if (ret < 0)
1424
                    goto fail_decode;
1425
                if (!got_subtitle) {
1426
                    goto discard_packet;
1427
                }
1428
                subtitle_to_free = &subtitle;
1429
                avpkt.size = 0;
1430
                break;
1431
            default:
1432
                goto fail_decode;
1433
            }
1434
        } else {
1435
            switch(ist->st->codec->codec_type) {
1436
            case AVMEDIA_TYPE_AUDIO:
1437
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1438
                    ist->st->codec->sample_rate;
1439
                break;
1440
            case AVMEDIA_TYPE_VIDEO:
1441
                if (ist->st->codec->time_base.num != 0) {
1442
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1443
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1444
                                      ist->st->codec->time_base.num * ticks) /
1445
                        ist->st->codec->time_base.den;
1446
                }
1447
                break;
1448
            }
1449
            ret = avpkt.size;
1450
            avpkt.size = 0;
1451
        }
1452

    
1453
        buffer_to_free = NULL;
1454
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1455
            pre_process_video_frame(ist, (AVPicture *)&picture,
1456
                                    &buffer_to_free);
1457
        }
1458

    
1459
        // preprocess audio (volume)
1460
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1461
            if (audio_volume != 256) {
1462
                short *volp;
1463
                volp = samples;
1464
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1465
                    int v = ((*volp) * audio_volume + 128) >> 8;
1466
                    if (v < -32768) v = -32768;
1467
                    if (v >  32767) v = 32767;
1468
                    *volp++ = v;
1469
                }
1470
            }
1471
        }
1472

    
1473
        /* frame rate emulation */
1474
        if (rate_emu) {
1475
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1476
            int64_t now = av_gettime() - ist->start;
1477
            if (pts > now)
1478
                usleep(pts - now);
1479
        }
1480

    
1481
        /* if output time reached then transcode raw format,
1482
           encode packets and output them */
1483
        if (start_time == 0 || ist->pts >= start_time)
1484
            for(i=0;i<nb_ostreams;i++) {
1485
                int frame_size;
1486

    
1487
                ost = ost_table[i];
1488
                if (ost->source_index == ist_index) {
1489
                    os = output_files[ost->file_index];
1490

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

    
1494
                    if (ost->encoding_needed) {
1495
                        assert(ist->decoding_needed);
1496
                        switch(ost->st->codec->codec_type) {
1497
                        case AVMEDIA_TYPE_AUDIO:
1498
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1499
                            break;
1500
                        case AVMEDIA_TYPE_VIDEO:
1501
                            do_video_out(os, ost, ist, &picture, &frame_size);
1502
                            if (vstats_filename && frame_size)
1503
                                do_video_stats(os, ost, frame_size);
1504
                            break;
1505
                        case AVMEDIA_TYPE_SUBTITLE:
1506
                            do_subtitle_out(os, ost, ist, &subtitle,
1507
                                            pkt->pts);
1508
                            break;
1509
                        default:
1510
                            abort();
1511
                        }
1512
                    } else {
1513
                        AVFrame avframe; //FIXME/XXX remove this
1514
                        AVPacket opkt;
1515
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1516

    
1517
                        av_init_packet(&opkt);
1518

    
1519
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1520
                            continue;
1521

    
1522
                        /* no reencoding needed : output the packet directly */
1523
                        /* force the input stream PTS */
1524

    
1525
                        avcodec_get_frame_defaults(&avframe);
1526
                        ost->st->codec->coded_frame= &avframe;
1527
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1528

    
1529
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1530
                            audio_size += data_size;
1531
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1532
                            video_size += data_size;
1533
                            ost->sync_opts++;
1534
                        }
1535

    
1536
                        opkt.stream_index= ost->index;
1537
                        if(pkt->pts != AV_NOPTS_VALUE)
1538
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1539
                        else
1540
                            opkt.pts= AV_NOPTS_VALUE;
1541

    
1542
                        if (pkt->dts == AV_NOPTS_VALUE)
1543
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1544
                        else
1545
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1546
                        opkt.dts -= ost_tb_start_time;
1547

    
1548
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1549
                        opkt.flags= pkt->flags;
1550

    
1551
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1552
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1553
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1554
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1555
                           ) {
1556
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1557
                                opkt.destruct= av_destruct_packet;
1558
                        } else {
1559
                            opkt.data = data_buf;
1560
                            opkt.size = data_size;
1561
                        }
1562

    
1563
                        write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1564
                        ost->st->codec->frame_number++;
1565
                        ost->frame_number++;
1566
                        av_free_packet(&opkt);
1567
                    }
1568
                }
1569
            }
1570
        av_free(buffer_to_free);
1571
        /* XXX: allocate the subtitles in the codec ? */
1572
        if (subtitle_to_free) {
1573
            if (subtitle_to_free->rects != NULL) {
1574
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1575
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1576
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1577
                    av_freep(&subtitle_to_free->rects[i]);
1578
                }
1579
                av_freep(&subtitle_to_free->rects);
1580
            }
1581
            subtitle_to_free->num_rects = 0;
1582
            subtitle_to_free = NULL;
1583
        }
1584
    }
1585
 discard_packet:
1586
    if (pkt == NULL) {
1587
        /* EOF handling */
1588

    
1589
        for(i=0;i<nb_ostreams;i++) {
1590
            ost = ost_table[i];
1591
            if (ost->source_index == ist_index) {
1592
                AVCodecContext *enc= ost->st->codec;
1593
                os = output_files[ost->file_index];
1594

    
1595
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1596
                    continue;
1597
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1598
                    continue;
1599

    
1600
                if (ost->encoding_needed) {
1601
                    for(;;) {
1602
                        AVPacket pkt;
1603
                        int fifo_bytes;
1604
                        av_init_packet(&pkt);
1605
                        pkt.stream_index= ost->index;
1606

    
1607
                        switch(ost->st->codec->codec_type) {
1608
                        case AVMEDIA_TYPE_AUDIO:
1609
                            fifo_bytes = av_fifo_size(ost->fifo);
1610
                            ret = 0;
1611
                            /* encode any samples remaining in fifo */
1612
                            if (fifo_bytes > 0) {
1613
                                int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1614
                                int fs_tmp = enc->frame_size;
1615

    
1616
                                av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1617
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1618
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1619
                                } else { /* pad */
1620
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1621
                                    if (samples_size < frame_bytes)
1622
                                        av_exit(1);
1623
                                    memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1624
                                }
1625

    
1626
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1627
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1628
                                                          ost->st->time_base.num, enc->sample_rate);
1629
                                enc->frame_size = fs_tmp;
1630
                            }
1631
                            if(ret <= 0) {
1632
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1633
                            }
1634
                            if (ret < 0) {
1635
                                fprintf(stderr, "Audio encoding failed\n");
1636
                                av_exit(1);
1637
                            }
1638
                            audio_size += ret;
1639
                            pkt.flags |= AV_PKT_FLAG_KEY;
1640
                            break;
1641
                        case AVMEDIA_TYPE_VIDEO:
1642
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1643
                            if (ret < 0) {
1644
                                fprintf(stderr, "Video encoding failed\n");
1645
                                av_exit(1);
1646
                            }
1647
                            video_size += ret;
1648
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1649
                                pkt.flags |= AV_PKT_FLAG_KEY;
1650
                            if (ost->logfile && enc->stats_out) {
1651
                                fprintf(ost->logfile, "%s", enc->stats_out);
1652
                            }
1653
                            break;
1654
                        default:
1655
                            ret=-1;
1656
                        }
1657

    
1658
                        if(ret<=0)
1659
                            break;
1660
                        pkt.data= bit_buffer;
1661
                        pkt.size= ret;
1662
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1663
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1664
                        write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1665
                    }
1666
                }
1667
            }
1668
        }
1669
    }
1670

    
1671
    return 0;
1672
 fail_decode:
1673
    return -1;
1674
}
1675

    
1676
static void print_sdp(AVFormatContext **avc, int n)
1677
{
1678
    char sdp[2048];
1679

    
1680
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1681
    printf("SDP:\n%s\n", sdp);
1682
    fflush(stdout);
1683
}
1684

    
1685
static int copy_chapters(int infile, int outfile)
1686
{
1687
    AVFormatContext *is = input_files[infile];
1688
    AVFormatContext *os = output_files[outfile];
1689
    int i;
1690

    
1691
    for (i = 0; i < is->nb_chapters; i++) {
1692
        AVChapter *in_ch = is->chapters[i], *out_ch;
1693
        AVMetadataTag *t = NULL;
1694
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1695
                                      AV_TIME_BASE_Q, in_ch->time_base);
1696
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1697
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1698

    
1699

    
1700
        if (in_ch->end < ts_off)
1701
            continue;
1702
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1703
            break;
1704

    
1705
        out_ch = av_mallocz(sizeof(AVChapter));
1706
        if (!out_ch)
1707
            return AVERROR(ENOMEM);
1708

    
1709
        out_ch->id        = in_ch->id;
1710
        out_ch->time_base = in_ch->time_base;
1711
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1712
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1713

    
1714
        while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1715
            av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1716

    
1717
        os->nb_chapters++;
1718
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1719
        if (!os->chapters)
1720
            return AVERROR(ENOMEM);
1721
        os->chapters[os->nb_chapters - 1] = out_ch;
1722
    }
1723
    return 0;
1724
}
1725

    
1726
/*
1727
 * The following code is the main loop of the file converter
1728
 */
1729
static int av_transcode(AVFormatContext **output_files,
1730
                     int nb_output_files,
1731
                     AVFormatContext **input_files,
1732
                     int nb_input_files,
1733
                     AVStreamMap *stream_maps, int nb_stream_maps)
1734
{
1735
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1736
    AVFormatContext *is, *os;
1737
    AVCodecContext *codec, *icodec;
1738
    AVOutputStream *ost, **ost_table = NULL;
1739
    AVInputStream *ist, **ist_table = NULL;
1740
    AVInputFile *file_table;
1741
    char error[1024];
1742
    int key;
1743
    int want_sdp = 1;
1744
    uint8_t no_packet[MAX_FILES]={0};
1745
    int no_packet_count=0;
1746

    
1747
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1748
    if (!file_table)
1749
        goto fail;
1750

    
1751
    /* input stream init */
1752
    j = 0;
1753
    for(i=0;i<nb_input_files;i++) {
1754
        is = input_files[i];
1755
        file_table[i].ist_index = j;
1756
        file_table[i].nb_streams = is->nb_streams;
1757
        j += is->nb_streams;
1758
    }
1759
    nb_istreams = j;
1760

    
1761
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1762
    if (!ist_table)
1763
        goto fail;
1764

    
1765
    for(i=0;i<nb_istreams;i++) {
1766
        ist = av_mallocz(sizeof(AVInputStream));
1767
        if (!ist)
1768
            goto fail;
1769
        ist_table[i] = ist;
1770
    }
1771
    j = 0;
1772
    for(i=0;i<nb_input_files;i++) {
1773
        is = input_files[i];
1774
        for(k=0;k<is->nb_streams;k++) {
1775
            ist = ist_table[j++];
1776
            ist->st = is->streams[k];
1777
            ist->file_index = i;
1778
            ist->index = k;
1779
            ist->discard = 1; /* the stream is discarded by default
1780
                                 (changed later) */
1781

    
1782
            if (rate_emu) {
1783
                ist->start = av_gettime();
1784
            }
1785
        }
1786
    }
1787

    
1788
    /* output stream init */
1789
    nb_ostreams = 0;
1790
    for(i=0;i<nb_output_files;i++) {
1791
        os = output_files[i];
1792
        if (!os->nb_streams) {
1793
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1794
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1795
            av_exit(1);
1796
        }
1797
        nb_ostreams += os->nb_streams;
1798
    }
1799
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1800
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1801
        av_exit(1);
1802
    }
1803

    
1804
    /* Sanity check the mapping args -- do the input files & streams exist? */
1805
    for(i=0;i<nb_stream_maps;i++) {
1806
        int fi = stream_maps[i].file_index;
1807
        int si = stream_maps[i].stream_index;
1808

    
1809
        if (fi < 0 || fi > nb_input_files - 1 ||
1810
            si < 0 || si > file_table[fi].nb_streams - 1) {
1811
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1812
            av_exit(1);
1813
        }
1814
        fi = stream_maps[i].sync_file_index;
1815
        si = stream_maps[i].sync_stream_index;
1816
        if (fi < 0 || fi > nb_input_files - 1 ||
1817
            si < 0 || si > file_table[fi].nb_streams - 1) {
1818
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1819
            av_exit(1);
1820
        }
1821
    }
1822

    
1823
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1824
    if (!ost_table)
1825
        goto fail;
1826
    for(i=0;i<nb_ostreams;i++) {
1827
        ost = av_mallocz(sizeof(AVOutputStream));
1828
        if (!ost)
1829
            goto fail;
1830
        ost_table[i] = ost;
1831
    }
1832

    
1833
    n = 0;
1834
    for(k=0;k<nb_output_files;k++) {
1835
        os = output_files[k];
1836
        for(i=0;i<os->nb_streams;i++,n++) {
1837
            int found;
1838
            ost = ost_table[n];
1839
            ost->file_index = k;
1840
            ost->index = i;
1841
            ost->st = os->streams[i];
1842
            if (nb_stream_maps > 0) {
1843
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1844
                    stream_maps[n].stream_index;
1845

    
1846
                /* Sanity check that the stream types match */
1847
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1848
                    int i= ost->file_index;
1849
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
1850
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1851
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1852
                        ost->file_index, ost->index);
1853
                    av_exit(1);
1854
                }
1855

    
1856
            } else {
1857
                int best_nb_frames=-1;
1858
                    /* get corresponding input stream index : we select the first one with the right type */
1859
                    found = 0;
1860
                    for(j=0;j<nb_istreams;j++) {
1861
                        int skip=0;
1862
                        ist = ist_table[j];
1863
                        if(opt_programid){
1864
                            int pi,si;
1865
                            AVFormatContext *f= input_files[ ist->file_index ];
1866
                            skip=1;
1867
                            for(pi=0; pi<f->nb_programs; pi++){
1868
                                AVProgram *p= f->programs[pi];
1869
                                if(p->id == opt_programid)
1870
                                    for(si=0; si<p->nb_stream_indexes; si++){
1871
                                        if(f->streams[ p->stream_index[si] ] == ist->st)
1872
                                            skip=0;
1873
                                    }
1874
                            }
1875
                        }
1876
                        if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
1877
                            ist->st->codec->codec_type == ost->st->codec->codec_type) {
1878
                            if(best_nb_frames < ist->st->codec_info_nb_frames){
1879
                                best_nb_frames= ist->st->codec_info_nb_frames;
1880
                                ost->source_index = j;
1881
                                found = 1;
1882
                            }
1883
                        }
1884
                    }
1885

    
1886
                if (!found) {
1887
                    if(! opt_programid) {
1888
                        /* try again and reuse existing stream */
1889
                        for(j=0;j<nb_istreams;j++) {
1890
                            ist = ist_table[j];
1891
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
1892
                                && ist->st->discard != AVDISCARD_ALL) {
1893
                                ost->source_index = j;
1894
                                found = 1;
1895
                            }
1896
                        }
1897
                    }
1898
                    if (!found) {
1899
                        int i= ost->file_index;
1900
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
1901
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1902
                                ost->file_index, ost->index);
1903
                        av_exit(1);
1904
                    }
1905
                }
1906
            }
1907
            ist = ist_table[ost->source_index];
1908
            ist->discard = 0;
1909
            ost->sync_ist = (nb_stream_maps > 0) ?
1910
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1911
                         stream_maps[n].sync_stream_index] : ist;
1912
        }
1913
    }
1914

    
1915
    /* for each output stream, we compute the right encoding parameters */
1916
    for(i=0;i<nb_ostreams;i++) {
1917
        AVMetadataTag *t = NULL, *lang = NULL;
1918
        ost = ost_table[i];
1919
        os = output_files[ost->file_index];
1920
        ist = ist_table[ost->source_index];
1921

    
1922
        codec = ost->st->codec;
1923
        icodec = ist->st->codec;
1924

    
1925
        if (av_metadata_get(ist->st->metadata, "language", NULL, 0))
1926
            lang = av_metadata_get(ost->st->metadata, "language", NULL, 0);
1927
        while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
1928
            if (lang && !strcmp(t->key, "language"))
1929
                continue;
1930
            av_metadata_set2(&ost->st->metadata, t->key, t->value, 0);
1931
        }
1932

    
1933
        ost->st->disposition = ist->st->disposition;
1934
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1935
        codec->chroma_sample_location = icodec->chroma_sample_location;
1936

    
1937
        if (ost->st->stream_copy) {
1938
            /* if stream_copy is selected, no need to decode or encode */
1939
            codec->codec_id = icodec->codec_id;
1940
            codec->codec_type = icodec->codec_type;
1941

    
1942
            if(!codec->codec_tag){
1943
                if(   !os->oformat->codec_tag
1944
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1945
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1946
                    codec->codec_tag = icodec->codec_tag;
1947
            }
1948

    
1949
            codec->bit_rate = icodec->bit_rate;
1950
            codec->extradata= icodec->extradata;
1951
            codec->extradata_size= icodec->extradata_size;
1952
            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){
1953
                codec->time_base = icodec->time_base;
1954
                codec->time_base.num *= icodec->ticks_per_frame;
1955
            }else
1956
                codec->time_base = ist->st->time_base;
1957
            switch(codec->codec_type) {
1958
            case AVMEDIA_TYPE_AUDIO:
1959
                if(audio_volume != 256) {
1960
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1961
                    av_exit(1);
1962
                }
1963
                codec->channel_layout = icodec->channel_layout;
1964
                codec->sample_rate = icodec->sample_rate;
1965
                codec->channels = icodec->channels;
1966
                codec->frame_size = icodec->frame_size;
1967
                codec->block_align= icodec->block_align;
1968
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1969
                    codec->block_align= 0;
1970
                if(codec->codec_id == CODEC_ID_AC3)
1971
                    codec->block_align= 0;
1972
                break;
1973
            case AVMEDIA_TYPE_VIDEO:
1974
                codec->pix_fmt = icodec->pix_fmt;
1975
                codec->width = icodec->width;
1976
                codec->height = icodec->height;
1977
                codec->has_b_frames = icodec->has_b_frames;
1978
                break;
1979
            case AVMEDIA_TYPE_SUBTITLE:
1980
                codec->width = icodec->width;
1981
                codec->height = icodec->height;
1982
                break;
1983
            default:
1984
                abort();
1985
            }
1986
        } else {
1987
            switch(codec->codec_type) {
1988
            case AVMEDIA_TYPE_AUDIO:
1989
                ost->fifo= av_fifo_alloc(1024);
1990
                if(!ost->fifo)
1991
                    goto fail;
1992
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1993
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1994
                icodec->request_channels = codec->channels;
1995
                ist->decoding_needed = 1;
1996
                ost->encoding_needed = 1;
1997
                break;
1998
            case AVMEDIA_TYPE_VIDEO:
1999
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2000
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2001
                    av_exit(1);
2002
                }
2003
                ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
2004
                ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
2005
                ost->video_resample = ((codec->width != icodec->width -
2006
                                (frame_leftBand + frame_rightBand) +
2007
                                (frame_padleft + frame_padright)) ||
2008
                        (codec->height != icodec->height -
2009
                                (frame_topBand  + frame_bottomBand) +
2010
                                (frame_padtop + frame_padbottom)) ||
2011
                        (codec->pix_fmt != icodec->pix_fmt));
2012
                if (ost->video_crop) {
2013
                    ost->topBand    = ost->original_topBand    = frame_topBand;
2014
                    ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
2015
                    ost->leftBand   = ost->original_leftBand   = frame_leftBand;
2016
                    ost->rightBand  = ost->original_rightBand  = frame_rightBand;
2017
                }
2018
                if (ost->video_pad) {
2019
                    ost->padtop = frame_padtop;
2020
                    ost->padleft = frame_padleft;
2021
                    ost->padbottom = frame_padbottom;
2022
                    ost->padright = frame_padright;
2023
                    if (!ost->video_resample) {
2024
                        avcodec_get_frame_defaults(&ost->pict_tmp);
2025
                        if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2026
                                         codec->width, codec->height))
2027
                            goto fail;
2028
                    }
2029
                }
2030
                if (ost->video_resample) {
2031
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2032
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2033
                                         codec->width, codec->height)) {
2034
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2035
                        av_exit(1);
2036
                    }
2037
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2038
                    ost->img_resample_ctx = sws_getContext(
2039
                            icodec->width - (frame_leftBand + frame_rightBand),
2040
                            icodec->height - (frame_topBand + frame_bottomBand),
2041
                            icodec->pix_fmt,
2042
                            codec->width - (frame_padleft + frame_padright),
2043
                            codec->height - (frame_padtop + frame_padbottom),
2044
                            codec->pix_fmt,
2045
                            sws_flags, NULL, NULL, NULL);
2046
                    if (ost->img_resample_ctx == NULL) {
2047
                        fprintf(stderr, "Cannot get resampling context\n");
2048
                        av_exit(1);
2049
                    }
2050

    
2051
                    ost->original_height = icodec->height;
2052
                    ost->original_width  = icodec->width;
2053

    
2054
                    codec->bits_per_raw_sample= 0;
2055
                }
2056
                ost->resample_height = icodec->height - (frame_topBand  + frame_bottomBand);
2057
                ost->resample_width  = icodec->width  - (frame_leftBand + frame_rightBand);
2058
                ost->resample_pix_fmt= icodec->pix_fmt;
2059
                ost->encoding_needed = 1;
2060
                ist->decoding_needed = 1;
2061
                break;
2062
            case AVMEDIA_TYPE_SUBTITLE:
2063
                ost->encoding_needed = 1;
2064
                ist->decoding_needed = 1;
2065
                break;
2066
            default:
2067
                abort();
2068
                break;
2069
            }
2070
            /* two pass mode */
2071
            if (ost->encoding_needed &&
2072
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2073
                char logfilename[1024];
2074
                FILE *f;
2075

    
2076
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2077
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2078
                         i);
2079
                if (codec->flags & CODEC_FLAG_PASS1) {
2080
                    f = fopen(logfilename, "w");
2081
                    if (!f) {
2082
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2083
                        av_exit(1);
2084
                    }
2085
                    ost->logfile = f;
2086
                } else {
2087
                    char  *logbuffer;
2088
                    size_t logbuffer_size;
2089
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2090
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2091
                        av_exit(1);
2092
                    }
2093
                    codec->stats_in = logbuffer;
2094
                }
2095
            }
2096
        }
2097
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2098
            int size= codec->width * codec->height;
2099
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2100
        }
2101
    }
2102

    
2103
    if (!bit_buffer)
2104
        bit_buffer = av_malloc(bit_buffer_size);
2105
    if (!bit_buffer) {
2106
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2107
                bit_buffer_size);
2108
        ret = AVERROR(ENOMEM);
2109
        goto fail;
2110
    }
2111

    
2112
    /* open each encoder */
2113
    for(i=0;i<nb_ostreams;i++) {
2114
        ost = ost_table[i];
2115
        if (ost->encoding_needed) {
2116
            AVCodec *codec = output_codecs[i];
2117
            if (!codec)
2118
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2119
            if (!codec) {
2120
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2121
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2122
                ret = AVERROR(EINVAL);
2123
                goto dump_format;
2124
            }
2125
            if (avcodec_open(ost->st->codec, codec) < 0) {
2126
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2127
                        ost->file_index, ost->index);
2128
                ret = AVERROR(EINVAL);
2129
                goto dump_format;
2130
            }
2131
            extra_size += ost->st->codec->extradata_size;
2132
        }
2133
    }
2134

    
2135
    /* open each decoder */
2136
    for(i=0;i<nb_istreams;i++) {
2137
        ist = ist_table[i];
2138
        if (ist->decoding_needed) {
2139
            AVCodec *codec = input_codecs[i];
2140
            if (!codec)
2141
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2142
            if (!codec) {
2143
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2144
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2145
                ret = AVERROR(EINVAL);
2146
                goto dump_format;
2147
            }
2148
            if (avcodec_open(ist->st->codec, codec) < 0) {
2149
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2150
                        ist->file_index, ist->index);
2151
                ret = AVERROR(EINVAL);
2152
                goto dump_format;
2153
            }
2154
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2155
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2156
        }
2157
    }
2158

    
2159
    /* init pts */
2160
    for(i=0;i<nb_istreams;i++) {
2161
        AVStream *st;
2162
        ist = ist_table[i];
2163
        st= ist->st;
2164
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2165
        ist->next_pts = AV_NOPTS_VALUE;
2166
        ist->is_start = 1;
2167
    }
2168

    
2169
    /* set meta data information from input file if required */
2170
    for (i=0;i<nb_meta_data_maps;i++) {
2171
        AVFormatContext *out_file;
2172
        AVFormatContext *in_file;
2173
        AVMetadataTag *mtag;
2174

    
2175
        int out_file_index = meta_data_maps[i].out_file;
2176
        int in_file_index = meta_data_maps[i].in_file;
2177
        if (out_file_index < 0 || out_file_index >= nb_output_files) {
2178
            snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2179
                     out_file_index, out_file_index, in_file_index);
2180
            ret = AVERROR(EINVAL);
2181
            goto dump_format;
2182
        }
2183
        if (in_file_index < 0 || in_file_index >= nb_input_files) {
2184
            snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2185
                     in_file_index, out_file_index, in_file_index);
2186
            ret = AVERROR(EINVAL);
2187
            goto dump_format;
2188
        }
2189

    
2190
        out_file = output_files[out_file_index];
2191
        in_file = input_files[in_file_index];
2192

    
2193

    
2194
        mtag=NULL;
2195
        while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2196
            av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2197
        av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2198
                                    in_file->iformat->metadata_conv);
2199
    }
2200

    
2201
    /* copy chapters from the first input file that has them*/
2202
    for (i = 0; i < nb_input_files; i++) {
2203
        if (!input_files[i]->nb_chapters)
2204
            continue;
2205

    
2206
        for (j = 0; j < nb_output_files; j++)
2207
            if ((ret = copy_chapters(i, j)) < 0)
2208
                goto dump_format;
2209
    }
2210

    
2211
    /* open files and write file headers */
2212
    for(i=0;i<nb_output_files;i++) {
2213
        os = output_files[i];
2214
        if (av_write_header(os) < 0) {
2215
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2216
            ret = AVERROR(EINVAL);
2217
            goto dump_format;
2218
        }
2219
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2220
            want_sdp = 0;
2221
        }
2222
    }
2223

    
2224
 dump_format:
2225
    /* dump the file output parameters - cannot be done before in case
2226
       of stream copy */
2227
    for(i=0;i<nb_output_files;i++) {
2228
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2229
    }
2230

    
2231
    /* dump the stream mapping */
2232
    if (verbose >= 0) {
2233
        fprintf(stderr, "Stream mapping:\n");
2234
        for(i=0;i<nb_ostreams;i++) {
2235
            ost = ost_table[i];
2236
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2237
                    ist_table[ost->source_index]->file_index,
2238
                    ist_table[ost->source_index]->index,
2239
                    ost->file_index,
2240
                    ost->index);
2241
            if (ost->sync_ist != ist_table[ost->source_index])
2242
                fprintf(stderr, " [sync #%d.%d]",
2243
                        ost->sync_ist->file_index,
2244
                        ost->sync_ist->index);
2245
            fprintf(stderr, "\n");
2246
        }
2247
    }
2248

    
2249
    if (ret) {
2250
        fprintf(stderr, "%s\n", error);
2251
        goto fail;
2252
    }
2253

    
2254
    if (want_sdp) {
2255
        print_sdp(output_files, nb_output_files);
2256
    }
2257

    
2258
    if (!using_stdin && verbose >= 0) {
2259
        fprintf(stderr, "Press [q] to stop encoding\n");
2260
        url_set_interrupt_cb(decode_interrupt_cb);
2261
    }
2262
    term_init();
2263

    
2264
    timer_start = av_gettime();
2265

    
2266
    for(; received_sigterm == 0;) {
2267
        int file_index, ist_index;
2268
        AVPacket pkt;
2269
        double ipts_min;
2270
        double opts_min;
2271

    
2272
    redo:
2273
        ipts_min= 1e100;
2274
        opts_min= 1e100;
2275
        /* if 'q' pressed, exits */
2276
        if (!using_stdin) {
2277
            if (q_pressed)
2278
                break;
2279
            /* read_key() returns 0 on EOF */
2280
            key = read_key();
2281
            if (key == 'q')
2282
                break;
2283
        }
2284

    
2285
        /* select the stream that we must read now by looking at the
2286
           smallest output pts */
2287
        file_index = -1;
2288
        for(i=0;i<nb_ostreams;i++) {
2289
            double ipts, opts;
2290
            ost = ost_table[i];
2291
            os = output_files[ost->file_index];
2292
            ist = ist_table[ost->source_index];
2293
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2294
                continue;
2295
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2296
            ipts = (double)ist->pts;
2297
            if (!file_table[ist->file_index].eof_reached){
2298
                if(ipts < ipts_min) {
2299
                    ipts_min = ipts;
2300
                    if(input_sync ) file_index = ist->file_index;
2301
                }
2302
                if(opts < opts_min) {
2303
                    opts_min = opts;
2304
                    if(!input_sync) file_index = ist->file_index;
2305
                }
2306
            }
2307
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2308
                file_index= -1;
2309
                break;
2310
            }
2311
        }
2312
        /* if none, if is finished */
2313
        if (file_index < 0) {
2314
            if(no_packet_count){
2315
                no_packet_count=0;
2316
                memset(no_packet, 0, sizeof(no_packet));
2317
                usleep(10000);
2318
                continue;
2319
            }
2320
            break;
2321
        }
2322

    
2323
        /* finish if limit size exhausted */
2324
        if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2325
            break;
2326

    
2327
        /* read a frame from it and output it in the fifo */
2328
        is = input_files[file_index];
2329
        ret= av_read_frame(is, &pkt);
2330
        if(ret == AVERROR(EAGAIN)){
2331
            no_packet[file_index]=1;
2332
            no_packet_count++;
2333
            continue;
2334
        }
2335
        if (ret < 0) {
2336
            file_table[file_index].eof_reached = 1;
2337
            if (opt_shortest)
2338
                break;
2339
            else
2340
                continue;
2341
        }
2342

    
2343
        no_packet_count=0;
2344
        memset(no_packet, 0, sizeof(no_packet));
2345

    
2346
        if (do_pkt_dump) {
2347
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2348
        }
2349
        /* the following test is needed in case new streams appear
2350
           dynamically in stream : we ignore them */
2351
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2352
            goto discard_packet;
2353
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2354
        ist = ist_table[ist_index];
2355
        if (ist->discard)
2356
            goto discard_packet;
2357

    
2358
        if (pkt.dts != AV_NOPTS_VALUE)
2359
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2360
        if (pkt.pts != AV_NOPTS_VALUE)
2361
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2362

    
2363
        if(input_files_ts_scale[file_index][pkt.stream_index]){
2364
            if(pkt.pts != AV_NOPTS_VALUE)
2365
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2366
            if(pkt.dts != AV_NOPTS_VALUE)
2367
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2368
        }
2369

    
2370
//        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);
2371
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2372
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2373
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2374
            int64_t delta= pkt_dts - ist->next_pts;
2375
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2376
                input_files_ts_offset[ist->file_index]-= delta;
2377
                if (verbose > 2)
2378
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2379
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2380
                if(pkt.pts != AV_NOPTS_VALUE)
2381
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2382
            }
2383
        }
2384

    
2385
        /* finish if recording time exhausted */
2386
        if (recording_time != INT64_MAX &&
2387
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2388
            ist->is_past_recording_time = 1;
2389
            goto discard_packet;
2390
        }
2391

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

    
2395
            if (verbose >= 0)
2396
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2397
                        ist->file_index, ist->index);
2398
            if (exit_on_error)
2399
                av_exit(1);
2400
            av_free_packet(&pkt);
2401
            goto redo;
2402
        }
2403

    
2404
    discard_packet:
2405
        av_free_packet(&pkt);
2406

    
2407
        /* dump report by using the output first video and audio streams */
2408
        print_report(output_files, ost_table, nb_ostreams, 0);
2409
    }
2410

    
2411
    /* at the end of stream, we must flush the decoder buffers */
2412
    for(i=0;i<nb_istreams;i++) {
2413
        ist = ist_table[i];
2414
        if (ist->decoding_needed) {
2415
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2416
        }
2417
    }
2418

    
2419
    term_exit();
2420

    
2421
    /* write the trailer if needed and close file */
2422
    for(i=0;i<nb_output_files;i++) {
2423
        os = output_files[i];
2424
        av_write_trailer(os);
2425
    }
2426

    
2427
    /* dump report by using the first video and audio streams */
2428
    print_report(output_files, ost_table, nb_ostreams, 1);
2429

    
2430
    /* close each encoder */
2431
    for(i=0;i<nb_ostreams;i++) {
2432
        ost = ost_table[i];
2433
        if (ost->encoding_needed) {
2434
            av_freep(&ost->st->codec->stats_in);
2435
            avcodec_close(ost->st->codec);
2436
        }
2437
    }
2438

    
2439
    /* close each decoder */
2440
    for(i=0;i<nb_istreams;i++) {
2441
        ist = ist_table[i];
2442
        if (ist->decoding_needed) {
2443
            avcodec_close(ist->st->codec);
2444
        }
2445
    }
2446

    
2447
    /* finished ! */
2448
    ret = 0;
2449

    
2450
 fail:
2451
    av_freep(&bit_buffer);
2452
    av_free(file_table);
2453

    
2454
    if (ist_table) {
2455
        for(i=0;i<nb_istreams;i++) {
2456
            ist = ist_table[i];
2457
            av_free(ist);
2458
        }
2459
        av_free(ist_table);
2460
    }
2461
    if (ost_table) {
2462
        for(i=0;i<nb_ostreams;i++) {
2463
            ost = ost_table[i];
2464
            if (ost) {
2465
                if (ost->logfile) {
2466
                    fclose(ost->logfile);
2467
                    ost->logfile = NULL;
2468
                }
2469
                av_fifo_free(ost->fifo); /* works even if fifo is not
2470
                                             initialized but set to zero */
2471
                av_free(ost->pict_tmp.data[0]);
2472
                if (ost->video_resample)
2473
                    sws_freeContext(ost->img_resample_ctx);
2474
                if (ost->resample)
2475
                    audio_resample_close(ost->resample);
2476
                if (ost->reformat_ctx)
2477
                    av_audio_convert_free(ost->reformat_ctx);
2478
                av_free(ost);
2479
            }
2480
        }
2481
        av_free(ost_table);
2482
    }
2483
    return ret;
2484
}
2485

    
2486
static void opt_format(const char *arg)
2487
{
2488
    /* compatibility stuff for pgmyuv */
2489
    if (!strcmp(arg, "pgmyuv")) {
2490
        pgmyuv_compatibility_hack=1;
2491
//        opt_image_format(arg);
2492
        arg = "image2";
2493
        fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2494
    }
2495

    
2496
    last_asked_format = arg;
2497
}
2498

    
2499
static void opt_video_rc_override_string(const char *arg)
2500
{
2501
    video_rc_override_string = arg;
2502
}
2503

    
2504
static int opt_me_threshold(const char *opt, const char *arg)
2505
{
2506
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2507
    return 0;
2508
}
2509

    
2510
static int opt_verbose(const char *opt, const char *arg)
2511
{
2512
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2513
    return 0;
2514
}
2515

    
2516
static int opt_frame_rate(const char *opt, const char *arg)
2517
{
2518
    if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2519
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2520
        av_exit(1);
2521
    }
2522
    return 0;
2523
}
2524

    
2525
static int opt_bitrate(const char *opt, const char *arg)
2526
{
2527
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2528

    
2529
    opt_default(opt, arg);
2530

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

    
2534
    return 0;
2535
}
2536

    
2537
static void opt_frame_crop_top(const char *arg)
2538
{
2539
    frame_topBand = atoi(arg);
2540
    if (frame_topBand < 0) {
2541
        fprintf(stderr, "Incorrect top crop size\n");
2542
        av_exit(1);
2543
    }
2544
    if ((frame_topBand) >= frame_height){
2545
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2546
        av_exit(1);
2547
    }
2548
    frame_height -= frame_topBand;
2549
}
2550

    
2551
static void opt_frame_crop_bottom(const char *arg)
2552
{
2553
    frame_bottomBand = atoi(arg);
2554
    if (frame_bottomBand < 0) {
2555
        fprintf(stderr, "Incorrect bottom crop size\n");
2556
        av_exit(1);
2557
    }
2558
    if ((frame_bottomBand) >= frame_height){
2559
        fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2560
        av_exit(1);
2561
    }
2562
    frame_height -= frame_bottomBand;
2563
}
2564

    
2565
static void opt_frame_crop_left(const char *arg)
2566
{
2567
    frame_leftBand = atoi(arg);
2568
    if (frame_leftBand < 0) {
2569
        fprintf(stderr, "Incorrect left crop size\n");
2570
        av_exit(1);
2571
    }
2572
    if ((frame_leftBand) >= frame_width){
2573
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2574
        av_exit(1);
2575
    }
2576
    frame_width -= frame_leftBand;
2577
}
2578

    
2579
static void opt_frame_crop_right(const char *arg)
2580
{
2581
    frame_rightBand = atoi(arg);
2582
    if (frame_rightBand < 0) {
2583
        fprintf(stderr, "Incorrect right crop size\n");
2584
        av_exit(1);
2585
    }
2586
    if ((frame_rightBand) >= frame_width){
2587
        fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2588
        av_exit(1);
2589
    }
2590
    frame_width -= frame_rightBand;
2591
}
2592

    
2593
static void opt_frame_size(const char *arg)
2594
{
2595
    if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2596
        fprintf(stderr, "Incorrect frame size\n");
2597
        av_exit(1);
2598
    }
2599
}
2600

    
2601
static void opt_pad_color(const char *arg) {
2602
    /* Input is expected to be six hex digits similar to
2603
       how colors are expressed in html tags (but without the #) */
2604
    int rgb = strtol(arg, NULL, 16);
2605
    int r,g,b;
2606

    
2607
    r = (rgb >> 16);
2608
    g = ((rgb >> 8) & 255);
2609
    b = (rgb & 255);
2610

    
2611
    padcolor[0] = RGB_TO_Y(r,g,b);
2612
    padcolor[1] = RGB_TO_U(r,g,b,0);
2613
    padcolor[2] = RGB_TO_V(r,g,b,0);
2614
}
2615

    
2616
static void opt_frame_pad_top(const char *arg)
2617
{
2618
    frame_padtop = atoi(arg);
2619
    if (frame_padtop < 0) {
2620
        fprintf(stderr, "Incorrect top pad size\n");
2621
        av_exit(1);
2622
    }
2623
}
2624

    
2625
static void opt_frame_pad_bottom(const char *arg)
2626
{
2627
    frame_padbottom = atoi(arg);
2628
    if (frame_padbottom < 0) {
2629
        fprintf(stderr, "Incorrect bottom pad size\n");
2630
        av_exit(1);
2631
    }
2632
}
2633

    
2634

    
2635
static void opt_frame_pad_left(const char *arg)
2636
{
2637
    frame_padleft = atoi(arg);
2638
    if (frame_padleft < 0) {
2639
        fprintf(stderr, "Incorrect left pad size\n");
2640
        av_exit(1);
2641
    }
2642
}
2643

    
2644

    
2645
static void opt_frame_pad_right(const char *arg)
2646
{
2647
    frame_padright = atoi(arg);
2648
    if (frame_padright < 0) {
2649
        fprintf(stderr, "Incorrect right pad size\n");
2650
        av_exit(1);
2651
    }
2652
}
2653

    
2654
static void opt_frame_pix_fmt(const char *arg)
2655
{
2656
    if (strcmp(arg, "list")) {
2657
        frame_pix_fmt = av_get_pix_fmt(arg);
2658
        if (frame_pix_fmt == PIX_FMT_NONE) {
2659
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2660
            av_exit(1);
2661
        }
2662
    } else {
2663
        show_pix_fmts();
2664
        av_exit(0);
2665
    }
2666
}
2667

    
2668
static void opt_frame_aspect_ratio(const char *arg)
2669
{
2670
    int x = 0, y = 0;
2671
    double ar = 0;
2672
    const char *p;
2673
    char *end;
2674

    
2675
    p = strchr(arg, ':');
2676
    if (p) {
2677
        x = strtol(arg, &end, 10);
2678
        if (end == p)
2679
            y = strtol(end+1, &end, 10);
2680
        if (x > 0 && y > 0)
2681
            ar = (double)x / (double)y;
2682
    } else
2683
        ar = strtod(arg, NULL);
2684

    
2685
    if (!ar) {
2686
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2687
        av_exit(1);
2688
    }
2689
    frame_aspect_ratio = ar;
2690
}
2691

    
2692
static int opt_metadata(const char *opt, const char *arg)
2693
{
2694
    char *mid= strchr(arg, '=');
2695

    
2696
    if(!mid){
2697
        fprintf(stderr, "Missing =\n");
2698
        av_exit(1);
2699
    }
2700
    *mid++= 0;
2701

    
2702
    metadata_count++;
2703
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2704
    metadata[metadata_count-1].key  = av_strdup(arg);
2705
    metadata[metadata_count-1].value= av_strdup(mid);
2706

    
2707
    return 0;
2708
}
2709

    
2710
static void opt_qscale(const char *arg)
2711
{
2712
    video_qscale = atof(arg);
2713
    if (video_qscale <= 0 ||
2714
        video_qscale > 255) {
2715
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2716
        av_exit(1);
2717
    }
2718
}
2719

    
2720
static void opt_top_field_first(const char *arg)
2721
{
2722
    top_field_first= atoi(arg);
2723
}
2724

    
2725
static int opt_thread_count(const char *opt, const char *arg)
2726
{
2727
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2728
#if !HAVE_THREADS
2729
    if (verbose >= 0)
2730
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2731
#endif
2732
    return 0;
2733
}
2734

    
2735
static void opt_audio_sample_fmt(const char *arg)
2736
{
2737
    if (strcmp(arg, "list"))
2738
        audio_sample_fmt = avcodec_get_sample_fmt(arg);
2739
    else {
2740
        list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2741
        av_exit(0);
2742
    }
2743
}
2744

    
2745
static int opt_audio_rate(const char *opt, const char *arg)
2746
{
2747
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2748
    return 0;
2749
}
2750

    
2751
static int opt_audio_channels(const char *opt, const char *arg)
2752
{
2753
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2754
    return 0;
2755
}
2756

    
2757
static void opt_video_channel(const char *arg)
2758
{
2759
    video_channel = strtol(arg, NULL, 0);
2760
}
2761

    
2762
static void opt_video_standard(const char *arg)
2763
{
2764
    video_standard = av_strdup(arg);
2765
}
2766

    
2767
static void opt_codec(int *pstream_copy, char **pcodec_name,
2768
                      int codec_type, const char *arg)
2769
{
2770
    av_freep(pcodec_name);
2771
    if (!strcmp(arg, "copy")) {
2772
        *pstream_copy = 1;
2773
    } else {
2774
        *pcodec_name = av_strdup(arg);
2775
    }
2776
}
2777

    
2778
static void opt_audio_codec(const char *arg)
2779
{
2780
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2781
}
2782

    
2783
static void opt_audio_tag(const char *arg)
2784
{
2785
    char *tail;
2786
    audio_codec_tag= strtol(arg, &tail, 0);
2787

    
2788
    if(!tail || *tail)
2789
        audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2790
}
2791

    
2792
static void opt_video_tag(const char *arg)
2793
{
2794
    char *tail;
2795
    video_codec_tag= strtol(arg, &tail, 0);
2796

    
2797
    if(!tail || *tail)
2798
        video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2799
}
2800

    
2801
static void opt_video_codec(const char *arg)
2802
{
2803
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2804
}
2805

    
2806
static void opt_subtitle_codec(const char *arg)
2807
{
2808
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2809
}
2810

    
2811
static void opt_subtitle_tag(const char *arg)
2812
{
2813
    char *tail;
2814
    subtitle_codec_tag= strtol(arg, &tail, 0);
2815

    
2816
    if(!tail || *tail)
2817
        subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2818
}
2819

    
2820
static void opt_map(const char *arg)
2821
{
2822
    AVStreamMap *m;
2823
    char *p;
2824

    
2825
    m = &stream_maps[nb_stream_maps++];
2826

    
2827
    m->file_index = strtol(arg, &p, 0);
2828
    if (*p)
2829
        p++;
2830

    
2831
    m->stream_index = strtol(p, &p, 0);
2832
    if (*p) {
2833
        p++;
2834
        m->sync_file_index = strtol(p, &p, 0);
2835
        if (*p)
2836
            p++;
2837
        m->sync_stream_index = strtol(p, &p, 0);
2838
    } else {
2839
        m->sync_file_index = m->file_index;
2840
        m->sync_stream_index = m->stream_index;
2841
    }
2842
}
2843

    
2844
static void opt_map_meta_data(const char *arg)
2845
{
2846
    AVMetaDataMap *m;
2847
    char *p;
2848

    
2849
    m = &meta_data_maps[nb_meta_data_maps++];
2850

    
2851
    m->out_file = strtol(arg, &p, 0);
2852
    if (*p)
2853
        p++;
2854

    
2855
    m->in_file = strtol(p, &p, 0);
2856
}
2857

    
2858
static void opt_input_ts_scale(const char *arg)
2859
{
2860
    unsigned int stream;
2861
    double scale;
2862
    char *p;
2863

    
2864
    stream = strtol(arg, &p, 0);
2865
    if (*p)
2866
        p++;
2867
    scale= strtod(p, &p);
2868

    
2869
    if(stream >= MAX_STREAMS)
2870
        av_exit(1);
2871

    
2872
    input_files_ts_scale[nb_input_files][stream]= scale;
2873
}
2874

    
2875
static int opt_recording_time(const char *opt, const char *arg)
2876
{
2877
    recording_time = parse_time_or_die(opt, arg, 1);
2878
    return 0;
2879
}
2880

    
2881
static int opt_start_time(const char *opt, const char *arg)
2882
{
2883
    start_time = parse_time_or_die(opt, arg, 1);
2884
    return 0;
2885
}
2886

    
2887
static int opt_rec_timestamp(const char *opt, const char *arg)
2888
{
2889
    rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2890
    return 0;
2891
}
2892

    
2893
static int opt_input_ts_offset(const char *opt, const char *arg)
2894
{
2895
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2896
    return 0;
2897
}
2898

    
2899
static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2900
{
2901
    const char *codec_string = encoder ? "encoder" : "decoder";
2902
    AVCodec *codec;
2903

    
2904
    if(!name)
2905
        return CODEC_ID_NONE;
2906
    codec = encoder ?
2907
        avcodec_find_encoder_by_name(name) :
2908
        avcodec_find_decoder_by_name(name);
2909
    if(!codec) {
2910
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2911
        av_exit(1);
2912
    }
2913
    if(codec->type != type) {
2914
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2915
        av_exit(1);
2916
    }
2917
    return codec->id;
2918
}
2919

    
2920
static void opt_input_file(const char *filename)
2921
{
2922
    AVFormatContext *ic;
2923
    AVFormatParameters params, *ap = &params;
2924
    AVInputFormat *file_iformat = NULL;
2925
    int err, i, ret, rfps, rfps_base;
2926
    int64_t timestamp;
2927

    
2928
    if (last_asked_format) {
2929
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
2930
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2931
            av_exit(1);
2932
        }
2933
        last_asked_format = NULL;
2934
    }
2935

    
2936
    if (!strcmp(filename, "-"))
2937
        filename = "pipe:";
2938

    
2939
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2940
                    !strcmp(filename, "/dev/stdin");
2941

    
2942
    /* get default parameters from command line */
2943
    ic = avformat_alloc_context();
2944
    if (!ic) {
2945
        print_error(filename, AVERROR(ENOMEM));
2946
        av_exit(1);
2947
    }
2948

    
2949
    memset(ap, 0, sizeof(*ap));
2950
    ap->prealloced_context = 1;
2951
    ap->sample_rate = audio_sample_rate;
2952
    ap->channels = audio_channels;
2953
    ap->time_base.den = frame_rate.num;
2954
    ap->time_base.num = frame_rate.den;
2955
    ap->width = frame_width + frame_padleft + frame_padright;
2956
    ap->height = frame_height + frame_padtop + frame_padbottom;
2957
    ap->pix_fmt = frame_pix_fmt;
2958
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2959
    ap->channel = video_channel;
2960
    ap->standard = video_standard;
2961

    
2962
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2963

    
2964
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0);
2965
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0);
2966
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
2967
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2968

    
2969
    if(pgmyuv_compatibility_hack)
2970
        ic->video_codec_id= CODEC_ID_PGMYUV;
2971

    
2972
    /* open the input file with generic libav function */
2973
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2974
    if (err < 0) {
2975
        print_error(filename, err);
2976
        av_exit(1);
2977
    }
2978
    if(opt_programid) {
2979
        int i, j;
2980
        int found=0;
2981
        for(i=0; i<ic->nb_streams; i++){
2982
            ic->streams[i]->discard= AVDISCARD_ALL;
2983
        }
2984
        for(i=0; i<ic->nb_programs; i++){
2985
            AVProgram *p= ic->programs[i];
2986
            if(p->id != opt_programid){
2987
                p->discard = AVDISCARD_ALL;
2988
            }else{
2989
                found=1;
2990
                for(j=0; j<p->nb_stream_indexes; j++){
2991
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
2992
                }
2993
            }
2994
        }
2995
        if(!found){
2996
            fprintf(stderr, "Specified program id not found\n");
2997
            av_exit(1);
2998
        }
2999
        opt_programid=0;
3000
    }
3001

    
3002
    ic->loop_input = loop_input;
3003

    
3004
    /* If not enough info to get the stream parameters, we decode the
3005
       first frames to get it. (used in mpeg case for example) */
3006
    ret = av_find_stream_info(ic);
3007
    if (ret < 0 && verbose >= 0) {
3008
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3009
        av_exit(1);
3010
    }
3011

    
3012
    timestamp = start_time;
3013
    /* add the stream start time */
3014
    if (ic->start_time != AV_NOPTS_VALUE)
3015
        timestamp += ic->start_time;
3016

    
3017
    /* if seeking requested, we execute it */
3018
    if (start_time != 0) {
3019
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3020
        if (ret < 0) {
3021
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3022
                    filename, (double)timestamp / AV_TIME_BASE);
3023
        }
3024
        /* reset seek info */
3025
        start_time = 0;
3026
    }
3027

    
3028
    /* update the current parameters so that they match the one of the input stream */
3029
    for(i=0;i<ic->nb_streams;i++) {
3030
        AVStream *st = ic->streams[i];
3031
        AVCodecContext *enc = st->codec;
3032
        avcodec_thread_init(enc, thread_count);
3033
        switch(enc->codec_type) {
3034
        case AVMEDIA_TYPE_AUDIO:
3035
            set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3036
            //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
3037
            channel_layout = enc->channel_layout;
3038
            audio_channels = enc->channels;
3039
            audio_sample_rate = enc->sample_rate;
3040
            audio_sample_fmt = enc->sample_fmt;
3041
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
3042
            if(audio_disable)
3043
                st->discard= AVDISCARD_ALL;
3044
            break;
3045
        case AVMEDIA_TYPE_VIDEO:
3046
            set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
3047
            frame_height = enc->height;
3048
            frame_width = enc->width;
3049
            if(ic->streams[i]->sample_aspect_ratio.num)
3050
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3051
            else
3052
                frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
3053
            frame_aspect_ratio *= (float) enc->width / enc->height;
3054
            frame_pix_fmt = enc->pix_fmt;
3055
            rfps      = ic->streams[i]->r_frame_rate.num;
3056
            rfps_base = ic->streams[i]->r_frame_rate.den;
3057
            if(enc->lowres) {
3058
                enc->flags |= CODEC_FLAG_EMU_EDGE;
3059
                frame_height >>= enc->lowres;
3060
                frame_width  >>= enc->lowres;
3061
            }
3062
            if(me_threshold)
3063
                enc->debug |= FF_DEBUG_MV;
3064

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

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

    
3071
                    (float)rfps / rfps_base, rfps, rfps_base);
3072
            }
3073
            /* update the current frame rate to match the stream frame rate */
3074
            frame_rate.num = rfps;
3075
            frame_rate.den = rfps_base;
3076

    
3077
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3078
            if(video_disable)
3079
                st->discard= AVDISCARD_ALL;
3080
            else if(video_discard)
3081
                st->discard= video_discard;
3082
            break;
3083
        case AVMEDIA_TYPE_DATA:
3084
            break;
3085
        case AVMEDIA_TYPE_SUBTITLE:
3086
            input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3087
            if(subtitle_disable)
3088
                st->discard = AVDISCARD_ALL;
3089
            break;
3090
        case AVMEDIA_TYPE_ATTACHMENT:
3091
        case AVMEDIA_TYPE_UNKNOWN:
3092
            nb_icodecs++;
3093
            break;
3094
        default:
3095
            abort();
3096
        }
3097
    }
3098

    
3099
    input_files[nb_input_files] = ic;
3100
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3101
    /* dump the file content */
3102
    if (verbose >= 0)
3103
        dump_format(ic, nb_input_files, filename, 0);
3104

    
3105
    nb_input_files++;
3106

    
3107
    video_channel = 0;
3108

    
3109
    av_freep(&video_codec_name);
3110
    av_freep(&audio_codec_name);
3111
    av_freep(&subtitle_codec_name);
3112
}
3113

    
3114
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3115
                                         int *has_subtitle_ptr)
3116
{
3117
    int has_video, has_audio, has_subtitle, i, j;
3118
    AVFormatContext *ic;
3119

    
3120
    has_video = 0;
3121
    has_audio = 0;
3122
    has_subtitle = 0;
3123
    for(j=0;j<nb_input_files;j++) {
3124
        ic = input_files[j];
3125
        for(i=0;i<ic->nb_streams;i++) {
3126
            AVCodecContext *enc = ic->streams[i]->codec;
3127
            switch(enc->codec_type) {
3128
            case AVMEDIA_TYPE_AUDIO:
3129
                has_audio = 1;
3130
                break;
3131
            case AVMEDIA_TYPE_VIDEO:
3132
                has_video = 1;
3133
                break;
3134
            case AVMEDIA_TYPE_SUBTITLE:
3135
                has_subtitle = 1;
3136
                break;
3137
            case AVMEDIA_TYPE_DATA:
3138
            case AVMEDIA_TYPE_ATTACHMENT:
3139
            case AVMEDIA_TYPE_UNKNOWN:
3140
                break;
3141
            default:
3142
                abort();
3143
            }
3144
        }
3145
    }
3146
    *has_video_ptr = has_video;
3147
    *has_audio_ptr = has_audio;
3148
    *has_subtitle_ptr = has_subtitle;
3149
}
3150

    
3151
static void new_video_stream(AVFormatContext *oc)
3152
{
3153
    AVStream *st;
3154
    AVCodecContext *video_enc;
3155
    enum CodecID codec_id;
3156

    
3157
    st = av_new_stream(oc, oc->nb_streams);
3158
    if (!st) {
3159
        fprintf(stderr, "Could not alloc stream\n");
3160
        av_exit(1);
3161
    }
3162
    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO);
3163
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3164
    video_bitstream_filters= NULL;
3165

    
3166
    avcodec_thread_init(st->codec, thread_count);
3167

    
3168
    video_enc = st->codec;
3169

    
3170
    if(video_codec_tag)
3171
        video_enc->codec_tag= video_codec_tag;
3172

    
3173
    if(   (video_global_header&1)
3174
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3175
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3176
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3177
    }
3178
    if(video_global_header&2){
3179
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3180
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3181
    }
3182

    
3183
    if (video_stream_copy) {
3184
        st->stream_copy = 1;
3185
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3186
        video_enc->sample_aspect_ratio =
3187
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3188
    } else {
3189
        const char *p;
3190
        int i;
3191
        AVCodec *codec;
3192
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3193

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

    
3203
        video_enc->codec_id = codec_id;
3204

    
3205
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3206

    
3207
        if (codec && codec->supported_framerates && !force_fps)
3208
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3209
        video_enc->time_base.den = fps.num;
3210
        video_enc->time_base.num = fps.den;
3211

    
3212
        video_enc->width = frame_width + frame_padright + frame_padleft;
3213
        video_enc->height = frame_height + frame_padtop + frame_padbottom;
3214
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3215
        video_enc->pix_fmt = frame_pix_fmt;
3216
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3217

    
3218
        choose_pixel_fmt(st, codec);
3219

    
3220
        if (intra_only)
3221
            video_enc->gop_size = 0;
3222
        if (video_qscale || same_quality) {
3223
            video_enc->flags |= CODEC_FLAG_QSCALE;
3224
            video_enc->global_quality=
3225
                st->quality = FF_QP2LAMBDA * video_qscale;
3226
        }
3227

    
3228
        if(intra_matrix)
3229
            video_enc->intra_matrix = intra_matrix;
3230
        if(inter_matrix)
3231
            video_enc->inter_matrix = inter_matrix;
3232

    
3233
        p= video_rc_override_string;
3234
        for(i=0; p; i++){
3235
            int start, end, q;
3236
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3237
            if(e!=3){
3238
                fprintf(stderr, "error parsing rc_override\n");
3239
                av_exit(1);
3240
            }
3241
            video_enc->rc_override=
3242
                av_realloc(video_enc->rc_override,
3243
                           sizeof(RcOverride)*(i+1));
3244
            video_enc->rc_override[i].start_frame= start;
3245
            video_enc->rc_override[i].end_frame  = end;
3246
            if(q>0){
3247
                video_enc->rc_override[i].qscale= q;
3248
                video_enc->rc_override[i].quality_factor= 1.0;
3249
            }
3250
            else{
3251
                video_enc->rc_override[i].qscale= 0;
3252
                video_enc->rc_override[i].quality_factor= -q/100.0;
3253
            }
3254
            p= strchr(p, '/');
3255
            if(p) p++;
3256
        }
3257
        video_enc->rc_override_count=i;
3258
        if (!video_enc->rc_initial_buffer_occupancy)
3259
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3260
        video_enc->me_threshold= me_threshold;
3261
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3262

    
3263
        if (do_psnr)
3264
            video_enc->flags|= CODEC_FLAG_PSNR;
3265

    
3266
        /* two pass mode */
3267
        if (do_pass) {
3268
            if (do_pass == 1) {
3269
                video_enc->flags |= CODEC_FLAG_PASS1;
3270
            } else {
3271
                video_enc->flags |= CODEC_FLAG_PASS2;
3272
            }
3273
        }
3274
    }
3275
    nb_ocodecs++;
3276
    if (video_language) {
3277
        av_metadata_set(&st->metadata, "language", video_language);
3278
        av_freep(&video_language);
3279
    }
3280

    
3281
    /* reset some key parameters */
3282
    video_disable = 0;
3283
    av_freep(&video_codec_name);
3284
    video_stream_copy = 0;
3285
    frame_pix_fmt = PIX_FMT_NONE;
3286
}
3287

    
3288
static void new_audio_stream(AVFormatContext *oc)
3289
{
3290
    AVStream *st;
3291
    AVCodecContext *audio_enc;
3292
    enum CodecID codec_id;
3293

    
3294
    st = av_new_stream(oc, oc->nb_streams);
3295
    if (!st) {
3296
        fprintf(stderr, "Could not alloc stream\n");
3297
        av_exit(1);
3298
    }
3299
    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO);
3300

    
3301
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3302
    audio_bitstream_filters= NULL;
3303

    
3304
    avcodec_thread_init(st->codec, thread_count);
3305

    
3306
    audio_enc = st->codec;
3307
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3308

    
3309
    if(audio_codec_tag)
3310
        audio_enc->codec_tag= audio_codec_tag;
3311

    
3312
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3313
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3314
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3315
    }
3316
    if (audio_stream_copy) {
3317
        st->stream_copy = 1;
3318
        audio_enc->channels = audio_channels;
3319
    } else {
3320
        AVCodec *codec;
3321

    
3322
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3323

    
3324
        if (audio_codec_name) {
3325
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3326
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3327
            output_codecs[nb_ocodecs] = codec;
3328
        } else {
3329
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3330
            codec = avcodec_find_encoder(codec_id);
3331
        }
3332
        audio_enc->codec_id = codec_id;
3333

    
3334
        if (audio_qscale > QSCALE_NONE) {
3335
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3336
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3337
        }
3338
        audio_enc->channels = audio_channels;
3339
        audio_enc->sample_fmt = audio_sample_fmt;
3340
        audio_enc->channel_layout = channel_layout;
3341
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3342
            audio_enc->channel_layout = 0;
3343
        choose_sample_fmt(st, codec);
3344
    }
3345
    nb_ocodecs++;
3346
    audio_enc->sample_rate = audio_sample_rate;
3347
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3348
    if (audio_language) {
3349
        av_metadata_set(&st->metadata, "language", audio_language);
3350
        av_freep(&audio_language);
3351
    }
3352

    
3353
    /* reset some key parameters */
3354
    audio_disable = 0;
3355
    av_freep(&audio_codec_name);
3356
    audio_stream_copy = 0;
3357
}
3358

    
3359
static void new_subtitle_stream(AVFormatContext *oc)
3360
{
3361
    AVStream *st;
3362
    AVCodecContext *subtitle_enc;
3363

    
3364
    st = av_new_stream(oc, oc->nb_streams);
3365
    if (!st) {
3366
        fprintf(stderr, "Could not alloc stream\n");
3367
        av_exit(1);
3368
    }
3369
    avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE);
3370

    
3371
    bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3372
    subtitle_bitstream_filters= NULL;
3373

    
3374
    subtitle_enc = st->codec;
3375
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3376

    
3377
    if(subtitle_codec_tag)
3378
        subtitle_enc->codec_tag= subtitle_codec_tag;
3379

    
3380
    if (subtitle_stream_copy) {
3381
        st->stream_copy = 1;
3382
    } else {
3383
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3384
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3385
        output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3386
    }
3387
    nb_ocodecs++;
3388

    
3389
    if (subtitle_language) {
3390
        av_metadata_set(&st->metadata, "language", subtitle_language);
3391
        av_freep(&subtitle_language);
3392
    }
3393

    
3394
    subtitle_disable = 0;
3395
    av_freep(&subtitle_codec_name);
3396
    subtitle_stream_copy = 0;
3397
}
3398

    
3399
static void opt_new_audio_stream(void)
3400
{
3401
    AVFormatContext *oc;
3402
    if (nb_output_files <= 0) {
3403
        fprintf(stderr, "At least one output file must be specified\n");
3404
        av_exit(1);
3405
    }
3406
    oc = output_files[nb_output_files - 1];
3407
    new_audio_stream(oc);
3408
}
3409

    
3410
static void opt_new_video_stream(void)
3411
{
3412
    AVFormatContext *oc;
3413
    if (nb_output_files <= 0) {
3414
        fprintf(stderr, "At least one output file must be specified\n");
3415
        av_exit(1);
3416
    }
3417
    oc = output_files[nb_output_files - 1];
3418
    new_video_stream(oc);
3419
}
3420

    
3421
static void opt_new_subtitle_stream(void)
3422
{
3423
    AVFormatContext *oc;
3424
    if (nb_output_files <= 0) {
3425
        fprintf(stderr, "At least one output file must be specified\n");
3426
        av_exit(1);
3427
    }
3428
    oc = output_files[nb_output_files - 1];
3429
    new_subtitle_stream(oc);
3430
}
3431

    
3432
static void opt_output_file(const char *filename)
3433
{
3434
    AVFormatContext *oc;
3435
    int use_video, use_audio, use_subtitle;
3436
    int input_has_video, input_has_audio, input_has_subtitle;
3437
    AVFormatParameters params, *ap = &params;
3438
    AVOutputFormat *file_oformat;
3439

    
3440
    if (!strcmp(filename, "-"))
3441
        filename = "pipe:";
3442

    
3443
    oc = avformat_alloc_context();
3444
    if (!oc) {
3445
        print_error(filename, AVERROR(ENOMEM));
3446
        av_exit(1);
3447
    }
3448

    
3449
    if (last_asked_format) {
3450
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3451
        if (!file_oformat) {
3452
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3453
            av_exit(1);
3454
        }
3455
        last_asked_format = NULL;
3456
    } else {
3457
        file_oformat = av_guess_format(NULL, filename, NULL);
3458
        if (!file_oformat) {
3459
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3460
                    filename);
3461
            av_exit(1);
3462
        }
3463
    }
3464

    
3465
    oc->oformat = file_oformat;
3466
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3467

    
3468
    if (!strcmp(file_oformat->name, "ffm") &&
3469
        av_strstart(filename, "http:", NULL)) {
3470
        /* special case for files sent to ffserver: we get the stream
3471
           parameters from ffserver */
3472
        int err = read_ffserver_streams(oc, filename);
3473
        if (err < 0) {
3474
            print_error(filename, err);
3475
            av_exit(1);
3476
        }
3477
    } else {
3478
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3479
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3480
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3481

    
3482
        /* disable if no corresponding type found and at least one
3483
           input file */
3484
        if (nb_input_files > 0) {
3485
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3486
                                         &input_has_subtitle);
3487
            if (!input_has_video)
3488
                use_video = 0;
3489
            if (!input_has_audio)
3490
                use_audio = 0;
3491
            if (!input_has_subtitle)
3492
                use_subtitle = 0;
3493
        }
3494

    
3495
        /* manual disable */
3496
        if (audio_disable) {
3497
            use_audio = 0;
3498
        }
3499
        if (video_disable) {
3500
            use_video = 0;
3501
        }
3502
        if (subtitle_disable) {
3503
            use_subtitle = 0;
3504
        }
3505

    
3506
        if (use_video) {
3507
            new_video_stream(oc);
3508
        }
3509

    
3510
        if (use_audio) {
3511
            new_audio_stream(oc);
3512
        }
3513

    
3514
        if (use_subtitle) {
3515
            new_subtitle_stream(oc);
3516
        }
3517

    
3518
        oc->timestamp = rec_timestamp;
3519

    
3520
        for(; metadata_count>0; metadata_count--){
3521
            av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3522
                                           metadata[metadata_count-1].value);
3523
        }
3524
        av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3525
    }
3526

    
3527
    output_files[nb_output_files++] = oc;
3528

    
3529
    /* check filename in case of an image number is expected */
3530
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3531
        if (!av_filename_number_test(oc->filename)) {
3532
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3533
            av_exit(1);
3534
        }
3535
    }
3536

    
3537
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3538
        /* test if it already exists to avoid loosing precious files */
3539
        if (!file_overwrite &&
3540
            (strchr(filename, ':') == NULL ||
3541
             filename[1] == ':' ||
3542
             av_strstart(filename, "file:", NULL))) {
3543
            if (url_exist(filename)) {
3544
                if (!using_stdin) {
3545
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3546
                    fflush(stderr);
3547
                    if (!read_yesno()) {
3548
                        fprintf(stderr, "Not overwriting - exiting\n");
3549
                        av_exit(1);
3550
                    }
3551
                }
3552
                else {
3553
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3554
                    av_exit(1);
3555
                }
3556
            }
3557
        }
3558

    
3559
        /* open the file */
3560
        if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3561
            fprintf(stderr, "Could not open '%s'\n", filename);
3562
            av_exit(1);
3563
        }
3564
    }
3565

    
3566
    memset(ap, 0, sizeof(*ap));
3567
    if (av_set_parameters(oc, ap) < 0) {
3568
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3569
                oc->filename);
3570
        av_exit(1);
3571
    }
3572

    
3573
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3574
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3575
    oc->loop_output = loop_output;
3576
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3577

    
3578
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3579
}
3580

    
3581
/* same option as mencoder */
3582
static void opt_pass(const char *pass_str)
3583
{
3584
    int pass;
3585
    pass = atoi(pass_str);
3586
    if (pass != 1 && pass != 2) {
3587
        fprintf(stderr, "pass number can be only 1 or 2\n");
3588
        av_exit(1);
3589
    }
3590
    do_pass = pass;
3591
}
3592

    
3593
static int64_t getutime(void)
3594
{
3595
#if HAVE_GETRUSAGE
3596
    struct rusage rusage;
3597

    
3598
    getrusage(RUSAGE_SELF, &rusage);
3599
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3600
#elif HAVE_GETPROCESSTIMES
3601
    HANDLE proc;
3602
    FILETIME c, e, k, u;
3603
    proc = GetCurrentProcess();
3604
    GetProcessTimes(proc, &c, &e, &k, &u);
3605
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3606
#else
3607
    return av_gettime();
3608
#endif
3609
}
3610

    
3611
static int64_t getmaxrss(void)
3612
{
3613
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3614
    struct rusage rusage;
3615
    getrusage(RUSAGE_SELF, &rusage);
3616
    return (int64_t)rusage.ru_maxrss * 1024;
3617
#elif HAVE_GETPROCESSMEMORYINFO
3618
    HANDLE proc;
3619
    PROCESS_MEMORY_COUNTERS memcounters;
3620
    proc = GetCurrentProcess();
3621
    memcounters.cb = sizeof(memcounters);
3622
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3623
    return memcounters.PeakPagefileUsage;
3624
#else
3625
    return 0;
3626
#endif
3627
}
3628

    
3629
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3630
{
3631
    int i;
3632
    const char *p = str;
3633
    for(i = 0;; i++) {
3634
        dest[i] = atoi(p);
3635
        if(i == 63)
3636
            break;
3637
        p = strchr(p, ',');
3638
        if(!p) {
3639
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3640
            av_exit(1);
3641
        }
3642
        p++;
3643
    }
3644
}
3645

    
3646
static void opt_inter_matrix(const char *arg)
3647
{
3648
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3649
    parse_matrix_coeffs(inter_matrix, arg);
3650
}
3651

    
3652
static void opt_intra_matrix(const char *arg)
3653
{
3654
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3655
    parse_matrix_coeffs(intra_matrix, arg);
3656
}
3657

    
3658
/**
3659
 * Trivial log callback.
3660
 * Only suitable for show_help and similar since it lacks prefix handling.
3661
 */
3662
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3663
{
3664
    vfprintf(stdout, fmt, vl);
3665
}
3666

    
3667
static void show_usage(void)
3668
{
3669
    printf("Hyper fast Audio and Video encoder\n");
3670
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3671
    printf("\n");
3672
}
3673

    
3674
static void show_help(void)
3675
{
3676
    av_log_set_callback(log_callback_help);
3677
    show_usage();
3678
    show_help_options(options, "Main options:\n",
3679
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3680
    show_help_options(options, "\nAdvanced options:\n",
3681
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3682
                      OPT_EXPERT);
3683
    show_help_options(options, "\nVideo options:\n",
3684
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3685
                      OPT_VIDEO);
3686
    show_help_options(options, "\nAdvanced Video options:\n",
3687
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3688
                      OPT_VIDEO | OPT_EXPERT);
3689
    show_help_options(options, "\nAudio options:\n",
3690
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3691
                      OPT_AUDIO);
3692
    show_help_options(options, "\nAdvanced Audio options:\n",
3693
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3694
                      OPT_AUDIO | OPT_EXPERT);
3695
    show_help_options(options, "\nSubtitle options:\n",
3696
                      OPT_SUBTITLE | OPT_GRAB,
3697
                      OPT_SUBTITLE);
3698
    show_help_options(options, "\nAudio/Video grab options:\n",
3699
                      OPT_GRAB,
3700
                      OPT_GRAB);
3701
    printf("\n");
3702
    av_opt_show(avcodec_opts[0], NULL);
3703
    printf("\n");
3704
    av_opt_show(avformat_opts, NULL);
3705
    printf("\n");
3706
    av_opt_show(sws_opts, NULL);
3707
}
3708

    
3709
static void opt_target(const char *arg)
3710
{
3711
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3712
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3713

    
3714
    if(!strncmp(arg, "pal-", 4)) {
3715
        norm = PAL;
3716
        arg += 4;
3717
    } else if(!strncmp(arg, "ntsc-", 5)) {
3718
        norm = NTSC;
3719
        arg += 5;
3720
    } else if(!strncmp(arg, "film-", 5)) {
3721
        norm = FILM;
3722
        arg += 5;
3723
    } else {
3724
        int fr;
3725
        /* Calculate FR via float to avoid int overflow */
3726
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3727
        if(fr == 25000) {
3728
            norm = PAL;
3729
        } else if((fr == 29970) || (fr == 23976)) {
3730
            norm = NTSC;
3731
        } else {
3732
            /* Try to determine PAL/NTSC by peeking in the input files */
3733
            if(nb_input_files) {
3734
                int i, j;
3735
                for(j = 0; j < nb_input_files; j++) {
3736
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3737
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3738
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3739
                            continue;
3740
                        fr = c->time_base.den * 1000 / c->time_base.num;
3741
                        if(fr == 25000) {
3742
                            norm = PAL;
3743
                            break;
3744
                        } else if((fr == 29970) || (fr == 23976)) {
3745
                            norm = NTSC;
3746
                            break;
3747
                        }
3748
                    }
3749
                    if(norm != UNKNOWN)
3750
                        break;
3751
                }
3752
            }
3753
        }
3754
        if(verbose && norm != UNKNOWN)
3755
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3756
    }
3757

    
3758
    if(norm == UNKNOWN) {
3759
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3760
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3761
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3762
        av_exit(1);
3763
    }
3764

    
3765
    if(!strcmp(arg, "vcd")) {
3766

    
3767
        opt_video_codec("mpeg1video");
3768
        opt_audio_codec("mp2");
3769
        opt_format("vcd");
3770

    
3771
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3772
        opt_frame_rate(NULL, frame_rates[norm]);
3773
        opt_default("g", norm == PAL ? "15" : "18");
3774

    
3775
        opt_default("b", "1150000");
3776
        opt_default("maxrate", "1150000");
3777
        opt_default("minrate", "1150000");
3778
        opt_default("bufsize", "327680"); // 40*1024*8;
3779

    
3780
        opt_default("ab", "224000");
3781
        audio_sample_rate = 44100;
3782
        audio_channels = 2;
3783

    
3784
        opt_default("packetsize", "2324");
3785
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3786

    
3787
        /* We have to offset the PTS, so that it is consistent with the SCR.
3788
           SCR starts at 36000, but the first two packs contain only padding
3789
           and the first pack from the other stream, respectively, may also have
3790
           been written before.
3791
           So the real data starts at SCR 36000+3*1200. */
3792
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3793
    } else if(!strcmp(arg, "svcd")) {
3794

    
3795
        opt_video_codec("mpeg2video");
3796
        opt_audio_codec("mp2");
3797
        opt_format("svcd");
3798

    
3799
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3800
        opt_frame_rate(NULL, frame_rates[norm]);
3801
        opt_default("g", norm == PAL ? "15" : "18");
3802

    
3803
        opt_default("b", "2040000");
3804
        opt_default("maxrate", "2516000");
3805
        opt_default("minrate", "0"); //1145000;
3806
        opt_default("bufsize", "1835008"); //224*1024*8;
3807
        opt_default("flags", "+scan_offset");
3808

    
3809

    
3810
        opt_default("ab", "224000");
3811
        audio_sample_rate = 44100;
3812

    
3813
        opt_default("packetsize", "2324");
3814

    
3815
    } else if(!strcmp(arg, "dvd")) {
3816

    
3817
        opt_video_codec("mpeg2video");
3818
        opt_audio_codec("ac3");
3819
        opt_format("dvd");
3820

    
3821
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3822
        opt_frame_rate(NULL, frame_rates[norm]);
3823
        opt_default("g", norm == PAL ? "15" : "18");
3824

    
3825
        opt_default("b", "6000000");
3826
        opt_default("maxrate", "9000000");
3827
        opt_default("minrate", "0"); //1500000;
3828
        opt_default("bufsize", "1835008"); //224*1024*8;
3829

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

    
3833
        opt_default("ab", "448000");
3834
        audio_sample_rate = 48000;
3835

    
3836
    } else if(!strncmp(arg, "dv", 2)) {
3837

    
3838
        opt_format("dv");
3839

    
3840
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3841
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3842
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3843
        opt_frame_rate(NULL, frame_rates[norm]);
3844

    
3845
        audio_sample_rate = 48000;
3846
        audio_channels = 2;
3847

    
3848
    } else {
3849
        fprintf(stderr, "Unknown target: %s\n", arg);
3850
        av_exit(1);
3851
    }
3852
}
3853

    
3854
static void opt_vstats_file (const char *arg)
3855
{
3856
    av_free (vstats_filename);
3857
    vstats_filename=av_strdup (arg);
3858
}
3859

    
3860
static void opt_vstats (void)
3861
{
3862
    char filename[40];
3863
    time_t today2 = time(NULL);
3864
    struct tm *today = localtime(&today2);
3865

    
3866
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3867
             today->tm_sec);
3868
    opt_vstats_file(filename);
3869
}
3870

    
3871
static int opt_bsf(const char *opt, const char *arg)
3872
{
3873
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3874
    AVBitStreamFilterContext **bsfp;
3875

    
3876
    if(!bsfc){
3877
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3878
        av_exit(1);
3879
    }
3880

    
3881
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3882
          *opt == 'a' ? &audio_bitstream_filters :
3883
                        &subtitle_bitstream_filters;
3884
    while(*bsfp)
3885
        bsfp= &(*bsfp)->next;
3886

    
3887
    *bsfp= bsfc;
3888

    
3889
    return 0;
3890
}
3891

    
3892
static int opt_preset(const char *opt, const char *arg)
3893
{
3894
    FILE *f=NULL;
3895
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3896
    int i;
3897
    const char *base[2]= { getenv("HOME"),
3898
                           FFMPEG_DATADIR,
3899
                         };
3900

    
3901
    if (*opt != 'f') {
3902
        for(i=!base[0]; i<2 && !f; i++){
3903
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3904
            f= fopen(filename, "r");
3905
            if(!f){
3906
                char *codec_name= *opt == 'v' ? video_codec_name :
3907
                                  *opt == 'a' ? audio_codec_name :
3908
                                                subtitle_codec_name;
3909
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3910
                f= fopen(filename, "r");
3911
            }
3912
        }
3913
    } else {
3914
        av_strlcpy(filename, arg, sizeof(filename));
3915
        f= fopen(filename, "r");
3916
    }
3917

    
3918
    if(!f){
3919
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3920
        av_exit(1);
3921
    }
3922

    
3923
    while(!feof(f)){
3924
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
3925
        if(line[0] == '#' && !e)
3926
            continue;
3927
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3928
        if(e){
3929
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3930
            av_exit(1);
3931
        }
3932
        if(!strcmp(tmp, "acodec")){
3933
            opt_audio_codec(tmp2);
3934
        }else if(!strcmp(tmp, "vcodec")){
3935
            opt_video_codec(tmp2);
3936
        }else if(!strcmp(tmp, "scodec")){
3937
            opt_subtitle_codec(tmp2);
3938
        }else if(opt_default(tmp, tmp2) < 0){
3939
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3940
            av_exit(1);
3941
        }
3942
    }
3943

    
3944
    fclose(f);
3945

    
3946
    return 0;
3947
}
3948

    
3949
static const OptionDef options[] = {
3950
    /* main options */
3951
#include "cmdutils_common_opts.h"
3952
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3953
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3954
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3955
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3956
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3957
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3958
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3959
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3960
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3961
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3962
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3963
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3964
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
3965
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3966
      "add timings for benchmarking" },
3967
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
3968
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3969
      "dump each input packet" },
3970
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3971
      "when dumping packets, also dump the payload" },
3972
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3973
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3974
    { "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)", "" },
3975
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3976
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3977
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3978
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3979
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3980
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3981
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3982
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3983
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3984
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3985
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3986
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3987
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3988

    
3989
    /* video options */
3990
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3991
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3992
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3993
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3994
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3995
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3996
    { "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" },
3997
    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3998
    { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3999
    { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4000
    { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4001
    { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4002
    { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4003
    { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4004
    { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4005
    { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4006
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4007
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4008
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4009
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4010
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4011
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4012
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4013
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4014
      "use same video quality as source (implies VBR)" },
4015
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4016
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4017
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4018
      "deinterlace pictures" },
4019
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4020
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4021
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4022
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4023
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4024
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4025
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4026
    { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4027
    { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4028
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4029
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4030
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4031

    
4032
    /* audio options */
4033
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4034
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4035
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4036
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4037
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4038
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4039
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4040
    { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4041
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4042
    { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4043
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4044
    { "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" },
4045

    
4046
    /* subtitle options */
4047
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4048
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4049
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4050
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4051
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4052

    
4053
    /* grab options */
4054
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4055
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4056
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4057

    
4058
    /* muxer options */
4059
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4060
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4061

    
4062
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4063
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4064
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4065

    
4066
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4067
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4068
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4069
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4070

    
4071
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4072
    { NULL, },
4073
};
4074

    
4075
int main(int argc, char **argv)
4076
{
4077
    int i;
4078
    int64_t ti;
4079

    
4080
    avcodec_register_all();
4081
    avdevice_register_all();
4082
    av_register_all();
4083

    
4084
#if HAVE_ISATTY
4085
    if(isatty(STDIN_FILENO))
4086
        url_set_interrupt_cb(decode_interrupt_cb);
4087
#endif
4088

    
4089
    for(i=0; i<AVMEDIA_TYPE_NB; i++){
4090
        avcodec_opts[i]= avcodec_alloc_context2(i);
4091
    }
4092
    avformat_opts = avformat_alloc_context();
4093
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4094

    
4095
    show_banner();
4096

    
4097
    /* parse options */
4098
    parse_options(argc, argv, options, opt_output_file);
4099

    
4100
    if(nb_output_files <= 0 && nb_input_files == 0) {
4101
        show_usage();
4102
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4103
        av_exit(1);
4104
    }
4105

    
4106
    /* file converter / grab */
4107
    if (nb_output_files <= 0) {
4108
        fprintf(stderr, "At least one output file must be specified\n");
4109
        av_exit(1);
4110
    }
4111

    
4112
    if (nb_input_files == 0) {
4113
        fprintf(stderr, "At least one input file must be specified\n");
4114
        av_exit(1);
4115
    }
4116

    
4117
    ti = getutime();
4118
    if (av_transcode(output_files, nb_output_files, input_files, nb_input_files,
4119
                  stream_maps, nb_stream_maps) < 0)
4120
        av_exit(1);
4121
    ti = getutime() - ti;
4122
    if (do_benchmark) {
4123
        int maxrss = getmaxrss() / 1024;
4124
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4125
    }
4126

    
4127
    return av_exit(0);
4128
}