Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 335ee1aa

History | View | Annotate | Download (146 KB)

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

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

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

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

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

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

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

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

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

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

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

    
410
static int av_exit(int ret)
411
{
412
    int i;
413

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

    
438
    av_free(intra_matrix);
439
    av_free(inter_matrix);
440

    
441
    if (vstats_file)
442
        fclose(vstats_file);
443
    av_free(vstats_filename);
444

    
445
    av_free(opt_names);
446

    
447
    av_free(video_codec_name);
448
    av_free(audio_codec_name);
449
    av_free(subtitle_codec_name);
450

    
451
    av_free(video_standard);
452

    
453
#if CONFIG_POWERPC_PERF
454
    void powerpc_display_perf_report(void);
455
    powerpc_display_perf_report();
456
#endif /* CONFIG_POWERPC_PERF */
457

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

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

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

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

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

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

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

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

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

    
517
    if (!nopts)
518
        s->timestamp = av_gettime();
519

    
520
    av_close_input_file(ic);
521
    return 0;
522
}
523

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

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

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

    
553
        bsfc= bsfc->next;
554
    }
555

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

    
563
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
564

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

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

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

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

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

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

    
604
    if (enc->channels != dec->channels)
605
        ost->audio_resample = 1;
606

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

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

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

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

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

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

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

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

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

    
722
        frame_bytes = enc->frame_size * osize * enc->channels;
723

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

    
728
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
729

    
730
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
731

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

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

    
753
        ost->sync_opts += size_out / (osize * enc->channels);
754

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

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

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

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

    
791
    dec = ist->st->codec;
792

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

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

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

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

    
818
    if (picture != picture2)
819
        *picture = *picture2;
820
    *bufp = buf;
821
}
822

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

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

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

    
845
    enc = ost->st->codec;
846

    
847
    if (!subtitle_out) {
848
        subtitle_out = av_malloc(subtitle_out_max_size);
849
    }
850

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

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

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

    
889
static int bit_buffer_size= 1024*256;
890
static uint8_t *bit_buffer= NULL;
891

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

    
904
    avcodec_get_frame_defaults(&picture_crop_temp);
905
    avcodec_get_frame_defaults(&picture_pad_temp);
906

    
907
    enc = ost->st->codec;
908
    dec = ist->st->codec;
909

    
910
    /* by default, we output a single frame */
911
    nb_frames = 1;
912

    
913
    *frame_size = 0;
914

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

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

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

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

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

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

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

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

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

    
1001
            ost->topBand    = topBand;
1002
            ost->bottomBand = bottomBand;
1003
            ost->leftBand   = leftBand;
1004
            ost->rightBand  = rightBand;
1005

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1184

    
1185
    oc = output_files[0];
1186

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

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

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

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

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

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

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

    
1265
        fflush(stderr);
1266
    }
1267

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

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

    
1297
    if(ist->next_pts == AV_NOPTS_VALUE)
1298
        ist->next_pts= ist->pts;
1299

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1479
                        av_init_packet(&opkt);
1480

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

    
1484
                        /* no reencoding needed : output the packet directly */
1485
                        /* force the input stream PTS */
1486

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1633
    return 0;
1634
 fail_decode:
1635
    return -1;
1636
}
1637

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1843
        codec = ost->st->codec;
1844
        icodec = ist->st->codec;
1845

    
1846
        if (av_metadata_get(ist->st->metadata, "language", NULL, 0))
1847
            lang = av_metadata_get(ost->st->metadata, "language", NULL, 0);
1848
        while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
1849
            if (lang && !strcmp(t->key, "language"))
1850
                continue;
1851
            av_metadata_set2(&ost->st->metadata, t->key, t->value, 0);
1852
        }
1853

    
1854
        ost->st->disposition = ist->st->disposition;
1855
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1856
        codec->chroma_sample_location = icodec->chroma_sample_location;
1857

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

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

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

    
1972
                    ost->original_height = icodec->height;
1973
                    ost->original_width  = icodec->width;
1974

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

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

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

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

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

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

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

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

    
2124
        out_file = output_files[out_file_index];
2125
        in_file = input_files[in_file_index];
2126

    
2127

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

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

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

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

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

    
2178
    if (want_sdp) {
2179
        print_sdp(output_files, nb_output_files);
2180
    }
2181

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

    
2188
    timer_start = av_gettime();
2189

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

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

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

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

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

    
2267
        no_packet_count=0;
2268
        memset(no_packet, 0, sizeof(no_packet));
2269

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

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

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

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

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

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

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

    
2328
    discard_packet:
2329
        av_free_packet(&pkt);
2330

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

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

    
2343
    term_exit();
2344

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

    
2351
    /* dump report by using the first video and audio streams */
2352
    print_report(output_files, ost_table, nb_ostreams, 1);
2353

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

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

    
2371
    /* finished ! */
2372
    ret = 0;
2373

    
2374
 fail:
2375
    av_freep(&bit_buffer);
2376
    av_free(file_table);
2377

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

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

    
2420
    last_asked_format = arg;
2421
}
2422

    
2423
static void opt_video_rc_override_string(const char *arg)
2424
{
2425
    video_rc_override_string = arg;
2426
}
2427

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

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

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

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

    
2453
    opt_default(opt, arg);
2454

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

    
2458
    return 0;
2459
}
2460

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

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

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

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

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

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

    
2531
    r = (rgb >> 16);
2532
    g = ((rgb >> 8) & 255);
2533
    b = (rgb & 255);
2534

    
2535
    padcolor[0] = RGB_TO_Y(r,g,b);
2536
    padcolor[1] = RGB_TO_U(r,g,b,0);
2537
    padcolor[2] = RGB_TO_V(r,g,b,0);
2538
}
2539

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

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

    
2558

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

    
2568

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

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

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

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

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

    
2616
static int opt_metadata(const char *opt, const char *arg)
2617
{
2618
    char *mid= strchr(arg, '=');
2619

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

    
2626
    metadata_count++;
2627
    metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2628
    metadata[metadata_count-1].key  = av_strdup(arg);
2629
    metadata[metadata_count-1].value= av_strdup(mid);
2630

    
2631
    return 0;
2632
}
2633

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

    
2644
static void opt_top_field_first(const char *arg)
2645
{
2646
    top_field_first= atoi(arg);
2647
}
2648

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

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

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

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

    
2681
static void opt_video_channel(const char *arg)
2682
{
2683
    video_channel = strtol(arg, NULL, 0);
2684
}
2685

    
2686
static void opt_video_standard(const char *arg)
2687
{
2688
    video_standard = av_strdup(arg);
2689
}
2690

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

    
2702
static void opt_audio_codec(const char *arg)
2703
{
2704
    opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2705
}
2706

    
2707
static void opt_audio_tag(const char *arg)
2708
{
2709
    char *tail;
2710
    audio_codec_tag= strtol(arg, &tail, 0);
2711

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

    
2716
static void opt_video_tag(const char *arg)
2717
{
2718
    char *tail;
2719
    video_codec_tag= strtol(arg, &tail, 0);
2720

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

    
2725
static void opt_video_codec(const char *arg)
2726
{
2727
    opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2728
}
2729

    
2730
static void opt_subtitle_codec(const char *arg)
2731
{
2732
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2733
}
2734

    
2735
static void opt_subtitle_tag(const char *arg)
2736
{
2737
    char *tail;
2738
    subtitle_codec_tag= strtol(arg, &tail, 0);
2739

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

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

    
2749
    m = &stream_maps[nb_stream_maps++];
2750

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

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

    
2768
static void opt_map_meta_data(const char *arg)
2769
{
2770
    AVMetaDataMap *m;
2771
    char *p;
2772

    
2773
    m = &meta_data_maps[nb_meta_data_maps++];
2774

    
2775
    m->out_file = strtol(arg, &p, 0);
2776
    if (*p)
2777
        p++;
2778

    
2779
    m->in_file = strtol(p, &p, 0);
2780
}
2781

    
2782
static void opt_input_ts_scale(const char *arg)
2783
{
2784
    unsigned int stream;
2785
    double scale;
2786
    char *p;
2787

    
2788
    stream = strtol(arg, &p, 0);
2789
    if (*p)
2790
        p++;
2791
    scale= strtod(p, &p);
2792

    
2793
    if(stream >= MAX_STREAMS)
2794
        av_exit(1);
2795

    
2796
    input_files_ts_scale[nb_input_files][stream]= scale;
2797
}
2798

    
2799
static int opt_recording_time(const char *opt, const char *arg)
2800
{
2801
    recording_time = parse_time_or_die(opt, arg, 1);
2802
    return 0;
2803
}
2804

    
2805
static int opt_start_time(const char *opt, const char *arg)
2806
{
2807
    start_time = parse_time_or_die(opt, arg, 1);
2808
    return 0;
2809
}
2810

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

    
2817
static int opt_input_ts_offset(const char *opt, const char *arg)
2818
{
2819
    input_ts_offset = parse_time_or_die(opt, arg, 1);
2820
    return 0;
2821
}
2822

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

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

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

    
2852
    if (last_asked_format) {
2853
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
2854
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2855
            av_exit(1);
2856
        }
2857
        last_asked_format = NULL;
2858
    }
2859

    
2860
    if (!strcmp(filename, "-"))
2861
        filename = "pipe:";
2862

    
2863
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
2864
                    !strcmp(filename, "/dev/stdin");
2865

    
2866
    /* get default parameters from command line */
2867
    ic = avformat_alloc_context();
2868
    if (!ic) {
2869
        print_error(filename, AVERROR(ENOMEM));
2870
        av_exit(1);
2871
    }
2872

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

    
2886
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2887

    
2888
    ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2889
    ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2890
    ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2891
    ic->flags |= AVFMT_FLAG_NONBLOCK;
2892

    
2893
    if(pgmyuv_compatibility_hack)
2894
        ic->video_codec_id= CODEC_ID_PGMYUV;
2895

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

    
2926
    ic->loop_input = loop_input;
2927

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

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

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

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

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

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

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

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

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

    
3029
    nb_input_files++;
3030

    
3031
    video_channel = 0;
3032

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

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

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

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

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

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

    
3092
    video_enc = st->codec;
3093

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

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

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

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

    
3127
        video_enc->codec_id = codec_id;
3128

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3459
        oc->timestamp = rec_timestamp;
3460

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

    
3468
    output_files[nb_output_files++] = oc;
3469

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

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

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

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

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

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

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

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

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

    
3552
static int64_t getmaxrss(void)
3553
{
3554
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3555
    struct rusage rusage;
3556
    getrusage(RUSAGE_SELF, &rusage);
3557
    return (int64_t)rusage.ru_maxrss * 1024;
3558
#elif HAVE_GETPROCESSMEMORYINFO
3559
    HANDLE proc;
3560
    PROCESS_MEMORY_COUNTERS memcounters;
3561
    proc = GetCurrentProcess();
3562
    memcounters.cb = sizeof(memcounters);
3563
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3564
    return memcounters.PeakPagefileUsage;
3565
#else
3566
    return 0;
3567
#endif
3568
}
3569

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

    
3587
static void opt_inter_matrix(const char *arg)
3588
{
3589
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3590
    parse_matrix_coeffs(inter_matrix, arg);
3591
}
3592

    
3593
static void opt_intra_matrix(const char *arg)
3594
{
3595
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3596
    parse_matrix_coeffs(intra_matrix, arg);
3597
}
3598

    
3599
/**
3600
 * Trivial log callback.
3601
 * Only suitable for show_help and similar since it lacks prefix handling.
3602
 */
3603
static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3604
{
3605
    vfprintf(stdout, fmt, vl);
3606
}
3607

    
3608
static void show_usage(void)
3609
{
3610
    printf("Hyper fast Audio and Video encoder\n");
3611
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3612
    printf("\n");
3613
}
3614

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

    
3650
static void opt_target(const char *arg)
3651
{
3652
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3653
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3654

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

    
3699
    if(norm == UNKNOWN) {
3700
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3701
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3702
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3703
        av_exit(1);
3704
    }
3705

    
3706
    if(!strcmp(arg, "vcd")) {
3707

    
3708
        opt_video_codec("mpeg1video");
3709
        opt_audio_codec("mp2");
3710
        opt_format("vcd");
3711

    
3712
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3713
        opt_frame_rate(NULL, frame_rates[norm]);
3714
        opt_default("g", norm == PAL ? "15" : "18");
3715

    
3716
        opt_default("b", "1150000");
3717
        opt_default("maxrate", "1150000");
3718
        opt_default("minrate", "1150000");
3719
        opt_default("bufsize", "327680"); // 40*1024*8;
3720

    
3721
        opt_default("ab", "224000");
3722
        audio_sample_rate = 44100;
3723
        audio_channels = 2;
3724

    
3725
        opt_default("packetsize", "2324");
3726
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3727

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

    
3736
        opt_video_codec("mpeg2video");
3737
        opt_audio_codec("mp2");
3738
        opt_format("svcd");
3739

    
3740
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3741
        opt_frame_rate(NULL, frame_rates[norm]);
3742
        opt_default("g", norm == PAL ? "15" : "18");
3743

    
3744
        opt_default("b", "2040000");
3745
        opt_default("maxrate", "2516000");
3746
        opt_default("minrate", "0"); //1145000;
3747
        opt_default("bufsize", "1835008"); //224*1024*8;
3748
        opt_default("flags", "+scan_offset");
3749

    
3750

    
3751
        opt_default("ab", "224000");
3752
        audio_sample_rate = 44100;
3753

    
3754
        opt_default("packetsize", "2324");
3755

    
3756
    } else if(!strcmp(arg, "dvd")) {
3757

    
3758
        opt_video_codec("mpeg2video");
3759
        opt_audio_codec("ac3");
3760
        opt_format("dvd");
3761

    
3762
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3763
        opt_frame_rate(NULL, frame_rates[norm]);
3764
        opt_default("g", norm == PAL ? "15" : "18");
3765

    
3766
        opt_default("b", "6000000");
3767
        opt_default("maxrate", "9000000");
3768
        opt_default("minrate", "0"); //1500000;
3769
        opt_default("bufsize", "1835008"); //224*1024*8;
3770

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

    
3774
        opt_default("ab", "448000");
3775
        audio_sample_rate = 48000;
3776

    
3777
    } else if(!strncmp(arg, "dv", 2)) {
3778

    
3779
        opt_format("dv");
3780

    
3781
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3782
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3783
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3784
        opt_frame_rate(NULL, frame_rates[norm]);
3785

    
3786
        audio_sample_rate = 48000;
3787
        audio_channels = 2;
3788

    
3789
    } else {
3790
        fprintf(stderr, "Unknown target: %s\n", arg);
3791
        av_exit(1);
3792
    }
3793
}
3794

    
3795
static void opt_vstats_file (const char *arg)
3796
{
3797
    av_free (vstats_filename);
3798
    vstats_filename=av_strdup (arg);
3799
}
3800

    
3801
static void opt_vstats (void)
3802
{
3803
    char filename[40];
3804
    time_t today2 = time(NULL);
3805
    struct tm *today = localtime(&today2);
3806

    
3807
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3808
             today->tm_sec);
3809
    opt_vstats_file(filename);
3810
}
3811

    
3812
static int opt_bsf(const char *opt, const char *arg)
3813
{
3814
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3815
    AVBitStreamFilterContext **bsfp;
3816

    
3817
    if(!bsfc){
3818
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3819
        av_exit(1);
3820
    }
3821

    
3822
    bsfp= *opt == 'v' ? &video_bitstream_filters :
3823
          *opt == 'a' ? &audio_bitstream_filters :
3824
                        &subtitle_bitstream_filters;
3825
    while(*bsfp)
3826
        bsfp= &(*bsfp)->next;
3827

    
3828
    *bsfp= bsfc;
3829

    
3830
    return 0;
3831
}
3832

    
3833
static int opt_preset(const char *opt, const char *arg)
3834
{
3835
    FILE *f=NULL;
3836
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
3837
    int i;
3838
    const char *base[2]= { getenv("HOME"),
3839
                           FFMPEG_DATADIR,
3840
                         };
3841

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

    
3859
    if(!f){
3860
        fprintf(stderr, "File for preset '%s' not found\n", arg);
3861
        av_exit(1);
3862
    }
3863

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

    
3885
    fclose(f);
3886

    
3887
    return 0;
3888
}
3889

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

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

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

    
3987
    /* subtitle options */
3988
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3989
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3990
    { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3991
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3992
    { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3993

    
3994
    /* grab options */
3995
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3996
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3997
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3998

    
3999
    /* muxer options */
4000
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4001
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4002

    
4003
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4004
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4005
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4006

    
4007
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4008
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4009
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4010
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4011

    
4012
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4013
    { NULL, },
4014
};
4015

    
4016
int main(int argc, char **argv)
4017
{
4018
    int i;
4019
    int64_t ti;
4020

    
4021
    avcodec_register_all();
4022
    avdevice_register_all();
4023
    av_register_all();
4024

    
4025
#if HAVE_ISATTY
4026
    if(isatty(STDIN_FILENO))
4027
        url_set_interrupt_cb(decode_interrupt_cb);
4028
#endif
4029

    
4030
    for(i=0; i<CODEC_TYPE_NB; i++){
4031
        avcodec_opts[i]= avcodec_alloc_context2(i);
4032
    }
4033
    avformat_opts = avformat_alloc_context();
4034
    sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4035

    
4036
    show_banner();
4037

    
4038
    /* parse options */
4039
    parse_options(argc, argv, options, opt_output_file);
4040

    
4041
    if(nb_output_files <= 0 && nb_input_files == 0) {
4042
        show_usage();
4043
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4044
        av_exit(1);
4045
    }
4046

    
4047
    /* file converter / grab */
4048
    if (nb_output_files <= 0) {
4049
        fprintf(stderr, "At least one output file must be specified\n");
4050
        av_exit(1);
4051
    }
4052

    
4053
    if (nb_input_files == 0) {
4054
        fprintf(stderr, "At least one input file must be specified\n");
4055
        av_exit(1);
4056
    }
4057

    
4058
    ti = getutime();
4059
    if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4060
                  stream_maps, nb_stream_maps) < 0)
4061
        av_exit(1);
4062
    ti = getutime() - ti;
4063
    if (do_benchmark) {
4064
        int maxrss = getmaxrss() / 1024;
4065
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4066
    }
4067

    
4068
    return av_exit(0);
4069
}