Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 35fe66ab

History | View | Annotate | Download (163 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 "libavutil/opt.h"
38
#include "libavcodec/audioconvert.h"
39
#include "libavutil/audioconvert.h"
40
#include "libavutil/parseutils.h"
41
#include "libavutil/samplefmt.h"
42
#include "libavutil/colorspace.h"
43
#include "libavutil/fifo.h"
44
#include "libavutil/intreadwrite.h"
45
#include "libavutil/pixdesc.h"
46
#include "libavutil/avstring.h"
47
#include "libavutil/libm.h"
48
#include "libavformat/os_support.h"
49

    
50
#include "libavformat/ffm.h" // not public API
51

    
52
#if CONFIG_AVFILTER
53
# include "libavfilter/avfilter.h"
54
# include "libavfilter/avfiltergraph.h"
55
# include "libavfilter/vsrc_buffer.h"
56
#endif
57

    
58
#if HAVE_SYS_RESOURCE_H
59
#include <sys/types.h>
60
#include <sys/time.h>
61
#include <sys/resource.h>
62
#elif HAVE_GETPROCESSTIMES
63
#include <windows.h>
64
#endif
65
#if HAVE_GETPROCESSMEMORYINFO
66
#include <windows.h>
67
#include <psapi.h>
68
#endif
69

    
70
#if HAVE_SYS_SELECT_H
71
#include <sys/select.h>
72
#endif
73

    
74
#if HAVE_TERMIOS_H
75
#include <fcntl.h>
76
#include <sys/ioctl.h>
77
#include <sys/time.h>
78
#include <termios.h>
79
#elif HAVE_KBHIT
80
#include <conio.h>
81
#endif
82
#include <time.h>
83

    
84
#include "cmdutils.h"
85

    
86
#include "libavutil/avassert.h"
87

    
88
const char program_name[] = "ffmpeg";
89
const int program_birth_year = 2000;
90

    
91
/* select an input stream for an output stream */
92
typedef struct AVStreamMap {
93
    int file_index;
94
    int stream_index;
95
    int sync_file_index;
96
    int sync_stream_index;
97
} AVStreamMap;
98

    
99
/**
100
 * select an input file for an output file
101
 */
102
typedef struct AVMetaDataMap {
103
    int  file;      //< file index
104
    char type;      //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
105
    int  index;     //< stream/chapter/program number
106
} AVMetaDataMap;
107

    
108
typedef struct AVChapterMap {
109
    int in_file;
110
    int out_file;
111
} AVChapterMap;
112

    
113
static const OptionDef options[];
114

    
115
#define MAX_FILES 100
116
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
117

    
118
static const char *last_asked_format = NULL;
119
static AVFormatContext *input_files[MAX_FILES];
120
static int64_t input_files_ts_offset[MAX_FILES];
121
static double *input_files_ts_scale[MAX_FILES] = {NULL};
122
static AVCodec **input_codecs = NULL;
123
static int nb_input_files = 0;
124
static int nb_input_codecs = 0;
125
static int nb_input_files_ts_scale[MAX_FILES] = {0};
126

    
127
static AVFormatContext *output_files[MAX_FILES];
128
static AVCodec **output_codecs = NULL;
129
static int nb_output_files = 0;
130
static int nb_output_codecs = 0;
131

    
132
static AVStreamMap *stream_maps = NULL;
133
static int nb_stream_maps;
134

    
135
/* first item specifies output metadata, second is input */
136
static AVMetaDataMap (*meta_data_maps)[2] = NULL;
137
static int nb_meta_data_maps;
138
static int metadata_global_autocopy   = 1;
139
static int metadata_streams_autocopy  = 1;
140
static int metadata_chapters_autocopy = 1;
141

    
142
static AVChapterMap *chapter_maps = NULL;
143
static int nb_chapter_maps;
144

    
145
/* indexed by output file stream index */
146
static int *streamid_map = NULL;
147
static int nb_streamid_map = 0;
148

    
149
static int frame_width  = 0;
150
static int frame_height = 0;
151
static float frame_aspect_ratio = 0;
152
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
153
static int frame_bits_per_raw_sample = 0;
154
static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
155
static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
156
static AVRational frame_rate;
157
static float video_qscale = 0;
158
static uint16_t *intra_matrix = NULL;
159
static uint16_t *inter_matrix = NULL;
160
static const char *video_rc_override_string=NULL;
161
static int video_disable = 0;
162
static int video_discard = 0;
163
static char *video_codec_name = NULL;
164
static unsigned int video_codec_tag = 0;
165
static char *video_language = NULL;
166
static int same_quality = 0;
167
static int do_deinterlace = 0;
168
static int top_field_first = -1;
169
static int me_threshold = 0;
170
static int intra_dc_precision = 8;
171
static int loop_input = 0;
172
static int loop_output = AVFMT_NOOUTPUTLOOP;
173
static int qp_hist = 0;
174
#if CONFIG_AVFILTER
175
static char *vfilters = NULL;
176
#else
177
static unsigned int sws_flags = SWS_BICUBIC;
178
#endif
179

    
180
static int intra_only = 0;
181
static int audio_sample_rate = 44100;
182
static int64_t channel_layout = 0;
183
#define QSCALE_NONE -99999
184
static float audio_qscale = QSCALE_NONE;
185
static int audio_disable = 0;
186
static int audio_channels = 1;
187
static char  *audio_codec_name = NULL;
188
static unsigned int audio_codec_tag = 0;
189
static char *audio_language = NULL;
190

    
191
static int subtitle_disable = 0;
192
static char *subtitle_codec_name = NULL;
193
static char *subtitle_language = NULL;
194
static unsigned int subtitle_codec_tag = 0;
195

    
196
static float mux_preload= 0.5;
197
static float mux_max_delay= 0.7;
198

    
199
static int64_t recording_time = INT64_MAX;
200
static int64_t start_time = 0;
201
static int64_t recording_timestamp = 0;
202
static int64_t input_ts_offset = 0;
203
static int file_overwrite = 0;
204
static AVMetadata *metadata;
205
static int do_benchmark = 0;
206
static int do_hex_dump = 0;
207
static int do_pkt_dump = 0;
208
static int do_psnr = 0;
209
static int do_pass = 0;
210
static const char *pass_logfilename_prefix;
211
static int audio_stream_copy = 0;
212
static int video_stream_copy = 0;
213
static int subtitle_stream_copy = 0;
214
static int video_sync_method= -1;
215
static int audio_sync_method= 0;
216
static float audio_drift_threshold= 0.1;
217
static int copy_ts= 0;
218
static int copy_tb;
219
static int opt_shortest = 0;
220
static int video_global_header = 0;
221
static char *vstats_filename;
222
static FILE *vstats_file;
223
static int opt_programid = 0;
224
static int copy_initial_nonkeyframes = 0;
225

    
226
static int rate_emu = 0;
227

    
228
static int  video_channel = 0;
229
static char *video_standard;
230

    
231
static int audio_volume = 256;
232

    
233
static int exit_on_error = 0;
234
static int using_stdin = 0;
235
static int verbose = 1;
236
static int run_as_daemon  = 0;
237
static int thread_count= 1;
238
static int q_pressed = 0;
239
static int64_t video_size = 0;
240
static int64_t audio_size = 0;
241
static int64_t extra_size = 0;
242
static int nb_frames_dup = 0;
243
static int nb_frames_drop = 0;
244
static int input_sync;
245
static uint64_t limit_filesize = 0;
246
static int force_fps = 0;
247
static char *forced_key_frames = NULL;
248

    
249
static float dts_delta_threshold = 10;
250

    
251
static int64_t timer_start;
252

    
253
static uint8_t *audio_buf;
254
static uint8_t *audio_out;
255
static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
256

    
257
static short *samples;
258

    
259
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
260
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
261
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
262

    
263
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
264

    
265
struct AVInputStream;
266

    
267
typedef struct AVOutputStream {
268
    int file_index;          /* file index */
269
    int index;               /* stream index in the output file */
270
    int source_index;        /* AVInputStream index */
271
    AVStream *st;            /* stream in the output file */
272
    int encoding_needed;     /* true if encoding needed for this stream */
273
    int frame_number;
274
    /* input pts and corresponding output pts
275
       for A/V sync */
276
    //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
277
    struct AVInputStream *sync_ist; /* input stream to sync against */
278
    int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
279
    AVBitStreamFilterContext *bitstream_filters;
280
    /* video only */
281
    int video_resample;
282
    AVFrame pict_tmp;      /* temporary image for resampling */
283
    struct SwsContext *img_resample_ctx; /* for image resampling */
284
    int resample_height;
285
    int resample_width;
286
    int resample_pix_fmt;
287

    
288
    float frame_aspect_ratio;
289

    
290
    /* forced key frames */
291
    int64_t *forced_kf_pts;
292
    int forced_kf_count;
293
    int forced_kf_index;
294

    
295
    /* audio only */
296
    int audio_resample;
297
    ReSampleContext *resample; /* for audio resampling */
298
    int resample_sample_fmt;
299
    int resample_channels;
300
    int resample_sample_rate;
301
    int reformat_pair;
302
    AVAudioConvert *reformat_ctx;
303
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
304
    FILE *logfile;
305

    
306
#if CONFIG_AVFILTER
307
    AVFilterContext *output_video_filter;
308
    AVFilterContext *input_video_filter;
309
    AVFilterBufferRef *picref;
310
    char *avfilter;
311
    AVFilterGraph *graph;
312
#endif
313
} AVOutputStream;
314

    
315
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
316
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
317

    
318
typedef struct AVInputStream {
319
    int file_index;
320
    int index;
321
    AVStream *st;
322
    int discard;             /* true if stream data should be discarded */
323
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
324
    int64_t sample_index;      /* current sample */
325

    
326
    int64_t       start;     /* time when read started */
327
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
328
                                is not defined */
329
    int64_t       pts;       /* current pts */
330
    int is_start;            /* is 1 at the start and after a discontinuity */
331
    int showed_multi_packet_warning;
332
    int is_past_recording_time;
333
#if CONFIG_AVFILTER
334
    AVFrame *filter_frame;
335
    int has_filter_frame;
336
#endif
337
} AVInputStream;
338

    
339
typedef struct AVInputFile {
340
    int eof_reached;      /* true if eof reached */
341
    int ist_index;        /* index of first stream in ist_table */
342
    int buffer_size;      /* current total buffer size */
343
    int nb_streams;       /* nb streams we are aware of */
344
} AVInputFile;
345

    
346
#if HAVE_TERMIOS_H
347

    
348
/* init terminal so that we can grab keys */
349
static struct termios oldtty;
350
#endif
351

    
352
#if CONFIG_AVFILTER
353

    
354
static int configure_video_filters(AVInputStream *ist, AVOutputStream *ost)
355
{
356
    AVFilterContext *last_filter, *filter;
357
    /** filter graph containing all filters including input & output */
358
    AVCodecContext *codec = ost->st->codec;
359
    AVCodecContext *icodec = ist->st->codec;
360
    FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
361
    AVRational sample_aspect_ratio;
362
    char args[255];
363
    int ret;
364

    
365
    ost->graph = avfilter_graph_alloc();
366

    
367
    if (ist->st->sample_aspect_ratio.num){
368
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
369
    }else
370
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
371

    
372
    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
373
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
374
             sample_aspect_ratio.num, sample_aspect_ratio.den);
375

    
376
    ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
377
                                       "src", args, NULL, ost->graph);
378
    if (ret < 0)
379
        return ret;
380
    ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
381
                                       "out", NULL, &ffsink_ctx, ost->graph);
382
    if (ret < 0)
383
        return ret;
384
    last_filter = ost->input_video_filter;
385

    
386
    if (codec->width  != icodec->width || codec->height != icodec->height) {
387
        snprintf(args, 255, "%d:%d:flags=0x%X",
388
                 codec->width,
389
                 codec->height,
390
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
391
        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
392
                                                NULL, args, NULL, ost->graph)) < 0)
393
            return ret;
394
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
395
            return ret;
396
        last_filter = filter;
397
    }
398

    
399
    snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
400
    ost->graph->scale_sws_opts = av_strdup(args);
401

    
402
    if (ost->avfilter) {
403
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
404
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
405

    
406
        outputs->name    = av_strdup("in");
407
        outputs->filter_ctx = last_filter;
408
        outputs->pad_idx = 0;
409
        outputs->next    = NULL;
410

    
411
        inputs->name    = av_strdup("out");
412
        inputs->filter_ctx = ost->output_video_filter;
413
        inputs->pad_idx = 0;
414
        inputs->next    = NULL;
415

    
416
        if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
417
            return ret;
418
        av_freep(&ost->avfilter);
419
    } else {
420
        if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
421
            return ret;
422
    }
423

    
424
    if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
425
        return ret;
426

    
427
    codec->width  = ost->output_video_filter->inputs[0]->w;
428
    codec->height = ost->output_video_filter->inputs[0]->h;
429
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
430
        ost->frame_aspect_ratio ? // overriden by the -aspect cli option
431
        av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
432
        ost->output_video_filter->inputs[0]->sample_aspect_ratio;
433

    
434
    return 0;
435
}
436
#endif /* CONFIG_AVFILTER */
437

    
438
static void term_exit(void)
439
{
440
    av_log(NULL, AV_LOG_QUIET, "");
441
#if HAVE_TERMIOS_H
442
    if(!run_as_daemon)
443
        tcsetattr (0, TCSANOW, &oldtty);
444
#endif
445
}
446

    
447
static volatile int received_sigterm = 0;
448

    
449
static void
450
sigterm_handler(int sig)
451
{
452
    received_sigterm = sig;
453
    q_pressed++;
454
    term_exit();
455
}
456

    
457
static void term_init(void)
458
{
459
#if HAVE_TERMIOS_H
460
    if(!run_as_daemon){
461
    struct termios tty;
462

    
463
    tcgetattr (0, &tty);
464
    oldtty = tty;
465
    atexit(term_exit);
466

    
467
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
468
                          |INLCR|IGNCR|ICRNL|IXON);
469
    tty.c_oflag |= OPOST;
470
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
471
    tty.c_cflag &= ~(CSIZE|PARENB);
472
    tty.c_cflag |= CS8;
473
    tty.c_cc[VMIN] = 1;
474
    tty.c_cc[VTIME] = 0;
475

    
476
    tcsetattr (0, TCSANOW, &tty);
477
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
478
    }
479
#endif
480

    
481
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
482
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
483
#ifdef SIGXCPU
484
    signal(SIGXCPU, sigterm_handler);
485
#endif
486
}
487

    
488
/* read a key without blocking */
489
static int read_key(void)
490
{
491
#if HAVE_TERMIOS_H
492
    int n = 1;
493
    unsigned char ch;
494
    struct timeval tv;
495
    fd_set rfds;
496

    
497
    if(run_as_daemon)
498
        return -1;
499

    
500
    FD_ZERO(&rfds);
501
    FD_SET(0, &rfds);
502
    tv.tv_sec = 0;
503
    tv.tv_usec = 0;
504
    n = select(1, &rfds, NULL, NULL, &tv);
505
    if (n > 0) {
506
        n = read(0, &ch, 1);
507
        if (n == 1)
508
            return ch;
509

    
510
        return n;
511
    }
512
#elif HAVE_KBHIT
513
    if(kbhit())
514
        return(getch());
515
#endif
516
    return -1;
517
}
518

    
519
static int decode_interrupt_cb(void)
520
{
521
    q_pressed += read_key() == 'q';
522
    return q_pressed > 1;
523
}
524

    
525
static int ffmpeg_exit(int ret)
526
{
527
    int i;
528

    
529
    /* close files */
530
    for(i=0;i<nb_output_files;i++) {
531
        AVFormatContext *s = output_files[i];
532
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
533
            avio_close(s->pb);
534
        avformat_free_context(s);
535
        av_free(output_streams_for_file[i]);
536
    }
537
    for(i=0;i<nb_input_files;i++) {
538
        av_close_input_file(input_files[i]);
539
        av_free(input_files_ts_scale[i]);
540
    }
541

    
542
    av_free(intra_matrix);
543
    av_free(inter_matrix);
544

    
545
    if (vstats_file)
546
        fclose(vstats_file);
547
    av_free(vstats_filename);
548

    
549
    av_free(streamid_map);
550
    av_free(input_codecs);
551
    av_free(output_codecs);
552
    av_free(stream_maps);
553
    av_free(meta_data_maps);
554

    
555
    av_free(video_codec_name);
556
    av_free(audio_codec_name);
557
    av_free(subtitle_codec_name);
558

    
559
    av_free(video_standard);
560

    
561
    uninit_opts();
562
    av_free(audio_buf);
563
    av_free(audio_out);
564
    allocated_audio_buf_size= allocated_audio_out_size= 0;
565
    av_free(samples);
566

    
567
#if CONFIG_AVFILTER
568
    avfilter_uninit();
569
#endif
570

    
571
    if (received_sigterm) {
572
        fprintf(stderr,
573
            "Received signal %d: terminating.\n",
574
            (int) received_sigterm);
575
        exit (255);
576
    }
577

    
578
    exit(ret); /* not all OS-es handle main() return value */
579
    return ret;
580
}
581

    
582
/* similar to ff_dynarray_add() and av_fast_realloc() */
583
static void *grow_array(void *array, int elem_size, int *size, int new_size)
584
{
585
    if (new_size >= INT_MAX / elem_size) {
586
        fprintf(stderr, "Array too big.\n");
587
        ffmpeg_exit(1);
588
    }
589
    if (*size < new_size) {
590
        uint8_t *tmp = av_realloc(array, new_size*elem_size);
591
        if (!tmp) {
592
            fprintf(stderr, "Could not alloc buffer.\n");
593
            ffmpeg_exit(1);
594
        }
595
        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
596
        *size = new_size;
597
        return tmp;
598
    }
599
    return array;
600
}
601

    
602
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
603
{
604
    if(codec && codec->sample_fmts){
605
        const enum AVSampleFormat *p= codec->sample_fmts;
606
        for(; *p!=-1; p++){
607
            if(*p == st->codec->sample_fmt)
608
                break;
609
        }
610
        if (*p == -1) {
611
            av_log(NULL, AV_LOG_WARNING,
612
                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
613
                   av_get_sample_fmt_name(st->codec->sample_fmt),
614
                   codec->name,
615
                   av_get_sample_fmt_name(codec->sample_fmts[0]));
616
            st->codec->sample_fmt = codec->sample_fmts[0];
617
        }
618
    }
619
}
620

    
621
static void choose_sample_rate(AVStream *st, AVCodec *codec)
622
{
623
    if(codec && codec->supported_samplerates){
624
        const int *p= codec->supported_samplerates;
625
        int best=0;
626
        int best_dist=INT_MAX;
627
        for(; *p; p++){
628
            int dist= abs(st->codec->sample_rate - *p);
629
            if(dist < best_dist){
630
                best_dist= dist;
631
                best= *p;
632
            }
633
        }
634
        if(best_dist){
635
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
636
        }
637
        st->codec->sample_rate= best;
638
    }
639
}
640

    
641
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
642
{
643
    if(codec && codec->pix_fmts){
644
        const enum PixelFormat *p= codec->pix_fmts;
645
        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
646
            if(st->codec->codec_id==CODEC_ID_MJPEG){
647
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
648
            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
649
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
650
            }
651
        }
652
        for(; *p!=-1; p++){
653
            if(*p == st->codec->pix_fmt)
654
                break;
655
        }
656
        if (*p == -1) {
657
            if(st->codec->pix_fmt != PIX_FMT_NONE)
658
            av_log(NULL, AV_LOG_WARNING,
659
                   "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
660
                   av_pix_fmt_descriptors[st->codec->pix_fmt].name,
661
                   codec->name,
662
                   av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
663
            st->codec->pix_fmt = codec->pix_fmts[0];
664
        }
665
    }
666
}
667

    
668
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
669
{
670
    int idx = oc->nb_streams - 1;
671
    AVOutputStream *ost;
672

    
673
    output_streams_for_file[file_idx] =
674
        grow_array(output_streams_for_file[file_idx],
675
                   sizeof(*output_streams_for_file[file_idx]),
676
                   &nb_output_streams_for_file[file_idx],
677
                   oc->nb_streams);
678
    ost = output_streams_for_file[file_idx][idx] =
679
        av_mallocz(sizeof(AVOutputStream));
680
    if (!ost) {
681
        fprintf(stderr, "Could not alloc output stream\n");
682
        ffmpeg_exit(1);
683
    }
684
    ost->file_index = file_idx;
685
    ost->index = idx;
686
    return ost;
687
}
688

    
689
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
690
{
691
    int i, err;
692
    AVFormatContext *ic;
693
    int nopts = 0;
694

    
695
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
696
    if (err < 0)
697
        return err;
698
    /* copy stream format */
699
    s->nb_streams = 0;
700
    for(i=0;i<ic->nb_streams;i++) {
701
        AVStream *st;
702
        AVCodec *codec;
703

    
704
        s->nb_streams++;
705

    
706
        // FIXME: a more elegant solution is needed
707
        st = av_mallocz(sizeof(AVStream));
708
        memcpy(st, ic->streams[i], sizeof(AVStream));
709
        st->codec = avcodec_alloc_context();
710
        if (!st->codec) {
711
            print_error(filename, AVERROR(ENOMEM));
712
            ffmpeg_exit(1);
713
        }
714
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
715
        s->streams[i] = st;
716

    
717
        codec = avcodec_find_encoder(st->codec->codec_id);
718
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
719
            if (audio_stream_copy) {
720
                st->stream_copy = 1;
721
            } else
722
                choose_sample_fmt(st, codec);
723
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
724
            if (video_stream_copy) {
725
                st->stream_copy = 1;
726
            } else
727
                choose_pixel_fmt(st, codec);
728
        }
729

    
730
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
731
            nopts = 1;
732

    
733
        new_output_stream(s, nb_output_files);
734
    }
735

    
736
    if (!nopts)
737
        s->timestamp = av_gettime();
738

    
739
    av_close_input_file(ic);
740
    return 0;
741
}
742

    
743
static double
744
get_sync_ipts(const AVOutputStream *ost)
745
{
746
    const AVInputStream *ist = ost->sync_ist;
747
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
748
}
749

    
750
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
751
    int ret;
752

    
753
    while(bsfc){
754
        AVPacket new_pkt= *pkt;
755
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
756
                                          &new_pkt.data, &new_pkt.size,
757
                                          pkt->data, pkt->size,
758
                                          pkt->flags & AV_PKT_FLAG_KEY);
759
        if(a>0){
760
            av_free_packet(pkt);
761
            new_pkt.destruct= av_destruct_packet;
762
        } else if(a<0){
763
            fprintf(stderr, "%s failed for stream %d, codec %s",
764
                    bsfc->filter->name, pkt->stream_index,
765
                    avctx->codec ? avctx->codec->name : "copy");
766
            print_error("", a);
767
            if (exit_on_error)
768
                ffmpeg_exit(1);
769
        }
770
        *pkt= new_pkt;
771

    
772
        bsfc= bsfc->next;
773
    }
774

    
775
    ret= av_interleaved_write_frame(s, pkt);
776
    if(ret < 0){
777
        print_error("av_interleaved_write_frame()", ret);
778
        ffmpeg_exit(1);
779
    }
780
}
781

    
782
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
783

    
784
static void do_audio_out(AVFormatContext *s,
785
                         AVOutputStream *ost,
786
                         AVInputStream *ist,
787
                         unsigned char *buf, int size)
788
{
789
    uint8_t *buftmp;
790
    int64_t audio_out_size, audio_buf_size;
791
    int64_t allocated_for_size= size;
792

    
793
    int size_out, frame_bytes, ret, resample_changed;
794
    AVCodecContext *enc= ost->st->codec;
795
    AVCodecContext *dec= ist->st->codec;
796
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
797
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
798
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
799

    
800
need_realloc:
801
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
802
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
803
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
804
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
805
    audio_buf_size*= osize*enc->channels;
806

    
807
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
808
    if(coded_bps > 8*osize)
809
        audio_out_size= audio_out_size * coded_bps / (8*osize);
810
    audio_out_size += FF_MIN_BUFFER_SIZE;
811

    
812
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
813
        fprintf(stderr, "Buffer sizes too large\n");
814
        ffmpeg_exit(1);
815
    }
816

    
817
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
818
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
819
    if (!audio_buf || !audio_out){
820
        fprintf(stderr, "Out of memory in do_audio_out\n");
821
        ffmpeg_exit(1);
822
    }
823

    
824
    if (enc->channels != dec->channels)
825
        ost->audio_resample = 1;
826

    
827
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
828
                       ost->resample_channels    != dec->channels   ||
829
                       ost->resample_sample_rate != dec->sample_rate;
830

    
831
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
832
        if (resample_changed) {
833
            av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
834
                   ist->file_index, ist->index,
835
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
836
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
837
            ost->resample_sample_fmt  = dec->sample_fmt;
838
            ost->resample_channels    = dec->channels;
839
            ost->resample_sample_rate = dec->sample_rate;
840
            if (ost->resample)
841
                audio_resample_close(ost->resample);
842
        }
843
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
844
        if (audio_sync_method <= 1 &&
845
            ost->resample_sample_fmt  == enc->sample_fmt &&
846
            ost->resample_channels    == enc->channels   &&
847
            ost->resample_sample_rate == enc->sample_rate) {
848
            ost->resample = NULL;
849
            ost->audio_resample = 0;
850
        } else {
851
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
852
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
853
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
854
                                                   enc->sample_rate, dec->sample_rate,
855
                                                   enc->sample_fmt,  dec->sample_fmt,
856
                                                   16, 10, 0, 0.8);
857
            if (!ost->resample) {
858
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
859
                        dec->channels, dec->sample_rate,
860
                        enc->channels, enc->sample_rate);
861
                ffmpeg_exit(1);
862
            }
863
        }
864
    }
865

    
866
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
867
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
868
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
869
        if (ost->reformat_ctx)
870
            av_audio_convert_free(ost->reformat_ctx);
871
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
872
                                                   dec->sample_fmt, 1, NULL, 0);
873
        if (!ost->reformat_ctx) {
874
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
875
                av_get_sample_fmt_name(dec->sample_fmt),
876
                av_get_sample_fmt_name(enc->sample_fmt));
877
            ffmpeg_exit(1);
878
        }
879
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
880
    }
881

    
882
    if(audio_sync_method){
883
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
884
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
885
        double idelta= delta*dec->sample_rate / enc->sample_rate;
886
        int byte_delta= ((int)idelta)*2*dec->channels;
887

    
888
        //FIXME resample delay
889
        if(fabs(delta) > 50){
890
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
891
                if(byte_delta < 0){
892
                    byte_delta= FFMAX(byte_delta, -size);
893
                    size += byte_delta;
894
                    buf  -= byte_delta;
895
                    if(verbose > 2)
896
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
897
                    if(!size)
898
                        return;
899
                    ist->is_start=0;
900
                }else{
901
                    static uint8_t *input_tmp= NULL;
902
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
903

    
904
                    if(byte_delta > allocated_for_size - size){
905
                        allocated_for_size= byte_delta + (int64_t)size;
906
                        goto need_realloc;
907
                    }
908
                    ist->is_start=0;
909

    
910
                    memset(input_tmp, 0, byte_delta);
911
                    memcpy(input_tmp + byte_delta, buf, size);
912
                    buf= input_tmp;
913
                    size += byte_delta;
914
                    if(verbose > 2)
915
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
916
                }
917
            }else if(audio_sync_method>1){
918
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
919
                av_assert0(ost->audio_resample);
920
                if(verbose > 2)
921
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
922
//                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));
923
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
924
            }
925
        }
926
    }else
927
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
928
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
929

    
930
    if (ost->audio_resample) {
931
        buftmp = audio_buf;
932
        size_out = audio_resample(ost->resample,
933
                                  (short *)buftmp, (short *)buf,
934
                                  size / (dec->channels * isize));
935
        size_out = size_out * enc->channels * osize;
936
    } else {
937
        buftmp = buf;
938
        size_out = size;
939
    }
940

    
941
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
942
        const void *ibuf[6]= {buftmp};
943
        void *obuf[6]= {audio_buf};
944
        int istride[6]= {isize};
945
        int ostride[6]= {osize};
946
        int len= size_out/istride[0];
947
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
948
            printf("av_audio_convert() failed\n");
949
            if (exit_on_error)
950
                ffmpeg_exit(1);
951
            return;
952
        }
953
        buftmp = audio_buf;
954
        size_out = len*osize;
955
    }
956

    
957
    /* now encode as many frames as possible */
958
    if (enc->frame_size > 1) {
959
        /* output resampled raw samples */
960
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
961
            fprintf(stderr, "av_fifo_realloc2() failed\n");
962
            ffmpeg_exit(1);
963
        }
964
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
965

    
966
        frame_bytes = enc->frame_size * osize * enc->channels;
967

    
968
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
969
            AVPacket pkt;
970
            av_init_packet(&pkt);
971

    
972
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
973

    
974
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
975

    
976
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
977
                                       (short *)audio_buf);
978
            if (ret < 0) {
979
                fprintf(stderr, "Audio encoding failed\n");
980
                ffmpeg_exit(1);
981
            }
982
            audio_size += ret;
983
            pkt.stream_index= ost->index;
984
            pkt.data= audio_out;
985
            pkt.size= ret;
986
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
987
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
988
            pkt.flags |= AV_PKT_FLAG_KEY;
989
            write_frame(s, &pkt, enc, ost->bitstream_filters);
990

    
991
            ost->sync_opts += enc->frame_size;
992
        }
993
    } else {
994
        AVPacket pkt;
995
        av_init_packet(&pkt);
996

    
997
        ost->sync_opts += size_out / (osize * enc->channels);
998

    
999
        /* output a pcm frame */
1000
        /* determine the size of the coded buffer */
1001
        size_out /= osize;
1002
        if (coded_bps)
1003
            size_out = size_out*coded_bps/8;
1004

    
1005
        if(size_out > audio_out_size){
1006
            fprintf(stderr, "Internal error, buffer size too small\n");
1007
            ffmpeg_exit(1);
1008
        }
1009

    
1010
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1011
        ret = avcodec_encode_audio(enc, audio_out, size_out,
1012
                                   (short *)buftmp);
1013
        if (ret < 0) {
1014
            fprintf(stderr, "Audio encoding failed\n");
1015
            ffmpeg_exit(1);
1016
        }
1017
        audio_size += ret;
1018
        pkt.stream_index= ost->index;
1019
        pkt.data= audio_out;
1020
        pkt.size= ret;
1021
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1022
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1023
        pkt.flags |= AV_PKT_FLAG_KEY;
1024
        write_frame(s, &pkt, enc, ost->bitstream_filters);
1025
    }
1026
}
1027

    
1028
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1029
{
1030
    AVCodecContext *dec;
1031
    AVPicture *picture2;
1032
    AVPicture picture_tmp;
1033
    uint8_t *buf = 0;
1034

    
1035
    dec = ist->st->codec;
1036

    
1037
    /* deinterlace : must be done before any resize */
1038
    if (do_deinterlace) {
1039
        int size;
1040

    
1041
        /* create temporary picture */
1042
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1043
        buf = av_malloc(size);
1044
        if (!buf)
1045
            return;
1046

    
1047
        picture2 = &picture_tmp;
1048
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1049

    
1050
        if(avpicture_deinterlace(picture2, picture,
1051
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1052
            /* if error, do not deinterlace */
1053
            fprintf(stderr, "Deinterlacing failed\n");
1054
            av_free(buf);
1055
            buf = NULL;
1056
            picture2 = picture;
1057
        }
1058
    } else {
1059
        picture2 = picture;
1060
    }
1061

    
1062
    if (picture != picture2)
1063
        *picture = *picture2;
1064
    *bufp = buf;
1065
}
1066

    
1067
/* we begin to correct av delay at this threshold */
1068
#define AV_DELAY_MAX 0.100
1069

    
1070
static void do_subtitle_out(AVFormatContext *s,
1071
                            AVOutputStream *ost,
1072
                            AVInputStream *ist,
1073
                            AVSubtitle *sub,
1074
                            int64_t pts)
1075
{
1076
    static uint8_t *subtitle_out = NULL;
1077
    int subtitle_out_max_size = 1024 * 1024;
1078
    int subtitle_out_size, nb, i;
1079
    AVCodecContext *enc;
1080
    AVPacket pkt;
1081

    
1082
    if (pts == AV_NOPTS_VALUE) {
1083
        fprintf(stderr, "Subtitle packets must have a pts\n");
1084
        if (exit_on_error)
1085
            ffmpeg_exit(1);
1086
        return;
1087
    }
1088

    
1089
    enc = ost->st->codec;
1090

    
1091
    if (!subtitle_out) {
1092
        subtitle_out = av_malloc(subtitle_out_max_size);
1093
    }
1094

    
1095
    /* Note: DVB subtitle need one packet to draw them and one other
1096
       packet to clear them */
1097
    /* XXX: signal it in the codec context ? */
1098
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1099
        nb = 2;
1100
    else
1101
        nb = 1;
1102

    
1103
    for(i = 0; i < nb; i++) {
1104
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1105
        // start_display_time is required to be 0
1106
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1107
        sub->end_display_time -= sub->start_display_time;
1108
        sub->start_display_time = 0;
1109
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1110
                                                    subtitle_out_max_size, sub);
1111
        if (subtitle_out_size < 0) {
1112
            fprintf(stderr, "Subtitle encoding failed\n");
1113
            ffmpeg_exit(1);
1114
        }
1115

    
1116
        av_init_packet(&pkt);
1117
        pkt.stream_index = ost->index;
1118
        pkt.data = subtitle_out;
1119
        pkt.size = subtitle_out_size;
1120
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1121
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1122
            /* XXX: the pts correction is handled here. Maybe handling
1123
               it in the codec would be better */
1124
            if (i == 0)
1125
                pkt.pts += 90 * sub->start_display_time;
1126
            else
1127
                pkt.pts += 90 * sub->end_display_time;
1128
        }
1129
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1130
    }
1131
}
1132

    
1133
static int bit_buffer_size= 1024*256;
1134
static uint8_t *bit_buffer= NULL;
1135

    
1136
static void do_video_out(AVFormatContext *s,
1137
                         AVOutputStream *ost,
1138
                         AVInputStream *ist,
1139
                         AVFrame *in_picture,
1140
                         int *frame_size)
1141
{
1142
    int nb_frames, i, ret, resample_changed;
1143
    AVFrame *final_picture, *formatted_picture, *resampling_dst;
1144
    AVCodecContext *enc, *dec;
1145
    double sync_ipts;
1146

    
1147
    enc = ost->st->codec;
1148
    dec = ist->st->codec;
1149

    
1150
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1151

    
1152
    /* by default, we output a single frame */
1153
    nb_frames = 1;
1154

    
1155
    *frame_size = 0;
1156

    
1157
    if(video_sync_method){
1158
        double vdelta = sync_ipts - ost->sync_opts;
1159
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1160
        if (vdelta < -1.1)
1161
            nb_frames = 0;
1162
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1163
            if(vdelta<=-0.6){
1164
                nb_frames=0;
1165
            }else if(vdelta>0.6)
1166
                ost->sync_opts= lrintf(sync_ipts);
1167
        }else if (vdelta > 1.1)
1168
            nb_frames = lrintf(vdelta);
1169
//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);
1170
        if (nb_frames == 0){
1171
            ++nb_frames_drop;
1172
            if (verbose>2)
1173
                fprintf(stderr, "*** drop!\n");
1174
        }else if (nb_frames > 1) {
1175
            nb_frames_dup += nb_frames - 1;
1176
            if (verbose>2)
1177
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1178
        }
1179
    }else
1180
        ost->sync_opts= lrintf(sync_ipts);
1181

    
1182
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1183
    if (nb_frames <= 0)
1184
        return;
1185

    
1186
    formatted_picture = in_picture;
1187
    final_picture = formatted_picture;
1188
    resampling_dst = &ost->pict_tmp;
1189

    
1190
    resample_changed = ost->resample_width   != dec->width  ||
1191
                       ost->resample_height  != dec->height ||
1192
                       ost->resample_pix_fmt != dec->pix_fmt;
1193

    
1194
    if (resample_changed) {
1195
        av_log(NULL, AV_LOG_INFO,
1196
               "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1197
               ist->file_index, ist->index,
1198
               ost->resample_width, ost->resample_height, avcodec_get_pix_fmt_name(ost->resample_pix_fmt),
1199
               dec->width         , dec->height         , avcodec_get_pix_fmt_name(dec->pix_fmt));
1200
        if(!ost->video_resample)
1201
            ffmpeg_exit(1);
1202
    }
1203

    
1204
#if !CONFIG_AVFILTER
1205
    if (ost->video_resample) {
1206
        final_picture = &ost->pict_tmp;
1207
        if (resample_changed) {
1208
            /* initialize a new scaler context */
1209
            sws_freeContext(ost->img_resample_ctx);
1210
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1211
            ost->img_resample_ctx = sws_getContext(
1212
                ist->st->codec->width,
1213
                ist->st->codec->height,
1214
                ist->st->codec->pix_fmt,
1215
                ost->st->codec->width,
1216
                ost->st->codec->height,
1217
                ost->st->codec->pix_fmt,
1218
                sws_flags, NULL, NULL, NULL);
1219
            if (ost->img_resample_ctx == NULL) {
1220
                fprintf(stderr, "Cannot get resampling context\n");
1221
                ffmpeg_exit(1);
1222
            }
1223
        }
1224
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1225
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1226
    }
1227
#endif
1228

    
1229
    /* duplicates frame if needed */
1230
    for(i=0;i<nb_frames;i++) {
1231
        AVPacket pkt;
1232
        av_init_packet(&pkt);
1233
        pkt.stream_index= ost->index;
1234

    
1235
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1236
            /* raw pictures are written as AVPicture structure to
1237
               avoid any copies. We support temorarily the older
1238
               method. */
1239
            AVFrame* old_frame = enc->coded_frame;
1240
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1241
            pkt.data= (uint8_t *)final_picture;
1242
            pkt.size=  sizeof(AVPicture);
1243
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1244
            pkt.flags |= AV_PKT_FLAG_KEY;
1245

    
1246
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1247
            enc->coded_frame = old_frame;
1248
        } else {
1249
            AVFrame big_picture;
1250

    
1251
            big_picture= *final_picture;
1252
            /* better than nothing: use input picture interlaced
1253
               settings */
1254
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1255
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1256
                if(top_field_first == -1)
1257
                    big_picture.top_field_first = in_picture->top_field_first;
1258
                else
1259
                    big_picture.top_field_first = top_field_first;
1260
            }
1261

    
1262
            /* handles sameq here. This is not correct because it may
1263
               not be a global option */
1264
            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1265
            if(!me_threshold)
1266
                big_picture.pict_type = 0;
1267
//            big_picture.pts = AV_NOPTS_VALUE;
1268
            big_picture.pts= ost->sync_opts;
1269
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1270
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1271
            if (ost->forced_kf_index < ost->forced_kf_count &&
1272
                big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1273
                big_picture.pict_type = FF_I_TYPE;
1274
                ost->forced_kf_index++;
1275
            }
1276
            ret = avcodec_encode_video(enc,
1277
                                       bit_buffer, bit_buffer_size,
1278
                                       &big_picture);
1279
            if (ret < 0) {
1280
                fprintf(stderr, "Video encoding failed\n");
1281
                ffmpeg_exit(1);
1282
            }
1283

    
1284
            if(ret>0){
1285
                pkt.data= bit_buffer;
1286
                pkt.size= ret;
1287
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1288
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1289
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1290
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1291
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1292

    
1293
                if(enc->coded_frame->key_frame)
1294
                    pkt.flags |= AV_PKT_FLAG_KEY;
1295
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1296
                *frame_size = ret;
1297
                video_size += ret;
1298
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1299
                //        enc->frame_number-1, ret, enc->pict_type);
1300
                /* if two pass, output log */
1301
                if (ost->logfile && enc->stats_out) {
1302
                    fprintf(ost->logfile, "%s", enc->stats_out);
1303
                }
1304
            }
1305
        }
1306
        ost->sync_opts++;
1307
        ost->frame_number++;
1308
    }
1309
}
1310

    
1311
static double psnr(double d){
1312
    return -10.0*log(d)/log(10.0);
1313
}
1314

    
1315
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1316
                           int frame_size)
1317
{
1318
    AVCodecContext *enc;
1319
    int frame_number;
1320
    double ti1, bitrate, avg_bitrate;
1321

    
1322
    /* this is executed just the first time do_video_stats is called */
1323
    if (!vstats_file) {
1324
        vstats_file = fopen(vstats_filename, "w");
1325
        if (!vstats_file) {
1326
            perror("fopen");
1327
            ffmpeg_exit(1);
1328
        }
1329
    }
1330

    
1331
    enc = ost->st->codec;
1332
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1333
        frame_number = ost->frame_number;
1334
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1335
        if (enc->flags&CODEC_FLAG_PSNR)
1336
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1337

    
1338
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1339
        /* compute pts value */
1340
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1341
        if (ti1 < 0.01)
1342
            ti1 = 0.01;
1343

    
1344
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1345
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1346
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1347
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1348
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1349
    }
1350
}
1351

    
1352
static void print_report(AVFormatContext **output_files,
1353
                         AVOutputStream **ost_table, int nb_ostreams,
1354
                         int is_last_report)
1355
{
1356
    char buf[1024];
1357
    AVOutputStream *ost;
1358
    AVFormatContext *oc;
1359
    int64_t total_size;
1360
    AVCodecContext *enc;
1361
    int frame_number, vid, i;
1362
    double bitrate, ti1, pts;
1363
    static int64_t last_time = -1;
1364
    static int qp_histogram[52];
1365

    
1366
    if (!is_last_report) {
1367
        int64_t cur_time;
1368
        /* display the report every 0.5 seconds */
1369
        cur_time = av_gettime();
1370
        if (last_time == -1) {
1371
            last_time = cur_time;
1372
            return;
1373
        }
1374
        if ((cur_time - last_time) < 500000)
1375
            return;
1376
        last_time = cur_time;
1377
    }
1378

    
1379

    
1380
    oc = output_files[0];
1381

    
1382
    total_size = avio_size(oc->pb);
1383
    if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1384
        total_size= avio_tell(oc->pb);
1385

    
1386
    buf[0] = '\0';
1387
    ti1 = 1e10;
1388
    vid = 0;
1389
    for(i=0;i<nb_ostreams;i++) {
1390
        float q= -1;
1391
        ost = ost_table[i];
1392
        enc = ost->st->codec;
1393
        if(!ost->st->stream_copy && enc->coded_frame)
1394
            q= enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1395
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1396
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1397
        }
1398
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1399
            float t = (av_gettime()-timer_start) / 1000000.0;
1400

    
1401
            frame_number = ost->frame_number;
1402
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1403
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1404
            if(is_last_report)
1405
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1406
            if(qp_hist){
1407
                int j;
1408
                int qp= lrintf(q);
1409
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1410
                    qp_histogram[qp]++;
1411
                for(j=0; j<32; j++)
1412
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1413
            }
1414
            if (enc->flags&CODEC_FLAG_PSNR){
1415
                int j;
1416
                double error, error_sum=0;
1417
                double scale, scale_sum=0;
1418
                char type[3]= {'Y','U','V'};
1419
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1420
                for(j=0; j<3; j++){
1421
                    if(is_last_report){
1422
                        error= enc->error[j];
1423
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1424
                    }else{
1425
                        error= enc->coded_frame->error[j];
1426
                        scale= enc->width*enc->height*255.0*255.0;
1427
                    }
1428
                    if(j) scale/=4;
1429
                    error_sum += error;
1430
                    scale_sum += scale;
1431
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1432
                }
1433
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1434
            }
1435
            vid = 1;
1436
        }
1437
        /* compute min output value */
1438
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1439
        if ((pts < ti1) && (pts > 0))
1440
            ti1 = pts;
1441
    }
1442
    if (ti1 < 0.01)
1443
        ti1 = 0.01;
1444

    
1445
    if (verbose > 0 || is_last_report) {
1446
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1447

    
1448
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1449
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1450
            (double)total_size / 1024, ti1, bitrate);
1451

    
1452
        if (nb_frames_dup || nb_frames_drop)
1453
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1454
                  nb_frames_dup, nb_frames_drop);
1455

    
1456
        if (verbose >= 0)
1457
            fprintf(stderr, "%s    \r", buf);
1458

    
1459
        fflush(stderr);
1460
    }
1461

    
1462
    if (is_last_report && verbose >= 0){
1463
        int64_t raw= audio_size + video_size + extra_size;
1464
        fprintf(stderr, "\n");
1465
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1466
                video_size/1024.0,
1467
                audio_size/1024.0,
1468
                extra_size/1024.0,
1469
                100.0*(total_size - raw)/raw
1470
        );
1471
    }
1472
}
1473

    
1474
static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1475
{
1476
    int fill_char = 0x00;
1477
    if (sample_fmt == AV_SAMPLE_FMT_U8)
1478
        fill_char = 0x80;
1479
    memset(buf, fill_char, size);
1480
}
1481

    
1482
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1483
static int output_packet(AVInputStream *ist, int ist_index,
1484
                         AVOutputStream **ost_table, int nb_ostreams,
1485
                         const AVPacket *pkt)
1486
{
1487
    AVFormatContext *os;
1488
    AVOutputStream *ost;
1489
    int ret, i;
1490
    int got_picture;
1491
    AVFrame picture;
1492
    void *buffer_to_free = NULL;
1493
    static unsigned int samples_size= 0;
1494
    AVSubtitle subtitle, *subtitle_to_free;
1495
    int64_t pkt_pts = AV_NOPTS_VALUE;
1496
#if CONFIG_AVFILTER
1497
    int frame_available;
1498
#endif
1499

    
1500
    AVPacket avpkt;
1501
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1502

    
1503
    if(ist->next_pts == AV_NOPTS_VALUE)
1504
        ist->next_pts= ist->pts;
1505

    
1506
    if (pkt == NULL) {
1507
        /* EOF handling */
1508
        av_init_packet(&avpkt);
1509
        avpkt.data = NULL;
1510
        avpkt.size = 0;
1511
        goto handle_eof;
1512
    } else {
1513
        avpkt = *pkt;
1514
    }
1515

    
1516
    if(pkt->dts != AV_NOPTS_VALUE)
1517
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1518
    if(pkt->pts != AV_NOPTS_VALUE)
1519
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1520

    
1521
    //while we have more to decode or while the decoder did output something on EOF
1522
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1523
        uint8_t *data_buf, *decoded_data_buf;
1524
        int data_size, decoded_data_size;
1525
    handle_eof:
1526
        ist->pts= ist->next_pts;
1527

    
1528
        if(avpkt.size && avpkt.size != pkt->size &&
1529
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1530
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1531
            ist->showed_multi_packet_warning=1;
1532
        }
1533

    
1534
        /* decode the packet if needed */
1535
        decoded_data_buf = NULL; /* fail safe */
1536
        decoded_data_size= 0;
1537
        data_buf  = avpkt.data;
1538
        data_size = avpkt.size;
1539
        subtitle_to_free = NULL;
1540
        if (ist->decoding_needed) {
1541
            switch(ist->st->codec->codec_type) {
1542
            case AVMEDIA_TYPE_AUDIO:{
1543
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1544
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1545
                    av_free(samples);
1546
                    samples= av_malloc(samples_size);
1547
                }
1548
                decoded_data_size= samples_size;
1549
                    /* XXX: could avoid copy if PCM 16 bits with same
1550
                       endianness as CPU */
1551
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1552
                                            &avpkt);
1553
                if (ret < 0)
1554
                    goto fail_decode;
1555
                avpkt.data += ret;
1556
                avpkt.size -= ret;
1557
                data_size   = ret;
1558
                /* Some bug in mpeg audio decoder gives */
1559
                /* decoded_data_size < 0, it seems they are overflows */
1560
                if (decoded_data_size <= 0) {
1561
                    /* no audio frame */
1562
                    continue;
1563
                }
1564
                decoded_data_buf = (uint8_t *)samples;
1565
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1566
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1567
                break;}
1568
            case AVMEDIA_TYPE_VIDEO:
1569
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1570
                    /* XXX: allocate picture correctly */
1571
                    avcodec_get_frame_defaults(&picture);
1572
                    avpkt.pts = pkt_pts;
1573
                    avpkt.dts = ist->pts;
1574
                    pkt_pts = AV_NOPTS_VALUE;
1575

    
1576
                    ret = avcodec_decode_video2(ist->st->codec,
1577
                                                &picture, &got_picture, &avpkt);
1578
                    ist->st->quality= picture.quality;
1579
                    if (ret < 0)
1580
                        goto fail_decode;
1581
                    if (!got_picture) {
1582
                        /* no picture yet */
1583
                        goto discard_packet;
1584
                    }
1585
                    ist->next_pts = ist->pts = picture.best_effort_timestamp;
1586
                    if (ist->st->codec->time_base.num != 0) {
1587
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1588
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1589
                                          ist->st->codec->time_base.num * ticks) /
1590
                            ist->st->codec->time_base.den;
1591
                    }
1592
                    avpkt.size = 0;
1593
                    buffer_to_free = NULL;
1594
                    pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1595
                    break;
1596
            case AVMEDIA_TYPE_SUBTITLE:
1597
                ret = avcodec_decode_subtitle2(ist->st->codec,
1598
                                               &subtitle, &got_picture, &avpkt);
1599
                if (ret < 0)
1600
                    goto fail_decode;
1601
                if (!got_picture) {
1602
                    goto discard_packet;
1603
                }
1604
                subtitle_to_free = &subtitle;
1605
                avpkt.size = 0;
1606
                break;
1607
            default:
1608
                goto fail_decode;
1609
            }
1610
        } else {
1611
            switch(ist->st->codec->codec_type) {
1612
            case AVMEDIA_TYPE_AUDIO:
1613
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1614
                    ist->st->codec->sample_rate;
1615
                break;
1616
            case AVMEDIA_TYPE_VIDEO:
1617
                if (ist->st->codec->time_base.num != 0) {
1618
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1619
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1620
                                      ist->st->codec->time_base.num * ticks) /
1621
                        ist->st->codec->time_base.den;
1622
                }
1623
                break;
1624
            }
1625
            ret = avpkt.size;
1626
            avpkt.size = 0;
1627
        }
1628

    
1629
#if CONFIG_AVFILTER
1630
        if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
1631
            for(i=0;i<nb_ostreams;i++) {
1632
                ost = ost_table[i];
1633
                if (ost->input_video_filter && ost->source_index == ist_index) {
1634
                    if (!picture.sample_aspect_ratio.num)
1635
                        picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1636
                    // add it to be filtered
1637
                    av_vsrc_buffer_add_frame2(ost->input_video_filter, &picture,
1638
                                             ist->pts,
1639
                                             ist->st->codec->width, ist->st->codec->height,
1640
                                             ist->st->codec->pix_fmt, ""); //TODO user setable params
1641
                }
1642
            }
1643
        }
1644
#endif
1645

    
1646
        // preprocess audio (volume)
1647
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1648
            if (audio_volume != 256) {
1649
                short *volp;
1650
                volp = samples;
1651
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1652
                    int v = ((*volp) * audio_volume + 128) >> 8;
1653
                    if (v < -32768) v = -32768;
1654
                    if (v >  32767) v = 32767;
1655
                    *volp++ = v;
1656
                }
1657
            }
1658
        }
1659

    
1660
        /* frame rate emulation */
1661
        if (rate_emu) {
1662
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1663
            int64_t now = av_gettime() - ist->start;
1664
            if (pts > now)
1665
                usleep(pts - now);
1666
        }
1667
        /* if output time reached then transcode raw format,
1668
           encode packets and output them */
1669
        if (start_time == 0 || ist->pts >= start_time)
1670
            for(i=0;i<nb_ostreams;i++) {
1671
                int frame_size;
1672

    
1673
                ost = ost_table[i];
1674
                if (ost->source_index == ist_index) {
1675
#if CONFIG_AVFILTER
1676
                frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1677
                    !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1678
                while (frame_available) {
1679
                    AVRational ist_pts_tb;
1680
                    if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1681
                        get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1682
                    if (ost->picref)
1683
                        ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1684
#endif
1685
                    os = output_files[ost->file_index];
1686

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

    
1690
                    if (ost->encoding_needed) {
1691
                        av_assert0(ist->decoding_needed);
1692
                        switch(ost->st->codec->codec_type) {
1693
                        case AVMEDIA_TYPE_AUDIO:
1694
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1695
                            break;
1696
                        case AVMEDIA_TYPE_VIDEO:
1697
#if CONFIG_AVFILTER
1698
                            if (ost->picref->video && !ost->frame_aspect_ratio)
1699
                                ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1700
#endif
1701
                            do_video_out(os, ost, ist, &picture, &frame_size);
1702
                            if (vstats_filename && frame_size)
1703
                                do_video_stats(os, ost, frame_size);
1704
                            break;
1705
                        case AVMEDIA_TYPE_SUBTITLE:
1706
                            do_subtitle_out(os, ost, ist, &subtitle,
1707
                                            pkt->pts);
1708
                            break;
1709
                        default:
1710
                            abort();
1711
                        }
1712
                    } else {
1713
                        AVFrame avframe; //FIXME/XXX remove this
1714
                        AVPacket opkt;
1715
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1716

    
1717
                        av_init_packet(&opkt);
1718

    
1719
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1720
#if !CONFIG_AVFILTER
1721
                            continue;
1722
#else
1723
                            goto cont;
1724
#endif
1725

    
1726
                        /* no reencoding needed : output the packet directly */
1727
                        /* force the input stream PTS */
1728

    
1729
                        avcodec_get_frame_defaults(&avframe);
1730
                        ost->st->codec->coded_frame= &avframe;
1731
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1732

    
1733
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1734
                            audio_size += data_size;
1735
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1736
                            video_size += data_size;
1737
                            ost->sync_opts++;
1738
                        }
1739

    
1740
                        opkt.stream_index= ost->index;
1741
                        if(pkt->pts != AV_NOPTS_VALUE)
1742
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1743
                        else
1744
                            opkt.pts= AV_NOPTS_VALUE;
1745

    
1746
                        if (pkt->dts == AV_NOPTS_VALUE)
1747
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1748
                        else
1749
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1750
                        opkt.dts -= ost_tb_start_time;
1751

    
1752
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1753
                        opkt.flags= pkt->flags;
1754

    
1755
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1756
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1757
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1758
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1759
                           ) {
1760
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1761
                                opkt.destruct= av_destruct_packet;
1762
                        } else {
1763
                            opkt.data = data_buf;
1764
                            opkt.size = data_size;
1765
                        }
1766

    
1767
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1768
                        ost->st->codec->frame_number++;
1769
                        ost->frame_number++;
1770
                        av_free_packet(&opkt);
1771
                    }
1772
#if CONFIG_AVFILTER
1773
                    cont:
1774
                    frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1775
                                       ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1776
                    if(ost->picref)
1777
                        avfilter_unref_buffer(ost->picref);
1778
                }
1779
#endif
1780
                }
1781
            }
1782

    
1783
        av_free(buffer_to_free);
1784
        /* XXX: allocate the subtitles in the codec ? */
1785
        if (subtitle_to_free) {
1786
            avsubtitle_free(subtitle_to_free);
1787
            subtitle_to_free = NULL;
1788
        }
1789
    }
1790
 discard_packet:
1791
    if (pkt == NULL) {
1792
        /* EOF handling */
1793

    
1794
        for(i=0;i<nb_ostreams;i++) {
1795
            ost = ost_table[i];
1796
            if (ost->source_index == ist_index) {
1797
                AVCodecContext *enc= ost->st->codec;
1798
                os = output_files[ost->file_index];
1799

    
1800
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1801
                    continue;
1802
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1803
                    continue;
1804

    
1805
                if (ost->encoding_needed) {
1806
                    for(;;) {
1807
                        AVPacket pkt;
1808
                        int fifo_bytes;
1809
                        av_init_packet(&pkt);
1810
                        pkt.stream_index= ost->index;
1811

    
1812
                        switch(ost->st->codec->codec_type) {
1813
                        case AVMEDIA_TYPE_AUDIO:
1814
                            fifo_bytes = av_fifo_size(ost->fifo);
1815
                            ret = 0;
1816
                            /* encode any samples remaining in fifo */
1817
                            if (fifo_bytes > 0) {
1818
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1819
                                int fs_tmp = enc->frame_size;
1820

    
1821
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1822
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1823
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1824
                                } else { /* pad */
1825
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1826
                                    if (allocated_audio_buf_size < frame_bytes)
1827
                                        ffmpeg_exit(1);
1828
                                    generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1829
                                }
1830

    
1831
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1832
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1833
                                                          ost->st->time_base.num, enc->sample_rate);
1834
                                enc->frame_size = fs_tmp;
1835
                            }
1836
                            if(ret <= 0) {
1837
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1838
                            }
1839
                            if (ret < 0) {
1840
                                fprintf(stderr, "Audio encoding failed\n");
1841
                                ffmpeg_exit(1);
1842
                            }
1843
                            audio_size += ret;
1844
                            pkt.flags |= AV_PKT_FLAG_KEY;
1845
                            break;
1846
                        case AVMEDIA_TYPE_VIDEO:
1847
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1848
                            if (ret < 0) {
1849
                                fprintf(stderr, "Video encoding failed\n");
1850
                                ffmpeg_exit(1);
1851
                            }
1852
                            video_size += ret;
1853
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1854
                                pkt.flags |= AV_PKT_FLAG_KEY;
1855
                            if (ost->logfile && enc->stats_out) {
1856
                                fprintf(ost->logfile, "%s", enc->stats_out);
1857
                            }
1858
                            break;
1859
                        default:
1860
                            ret=-1;
1861
                        }
1862

    
1863
                        if(ret<=0)
1864
                            break;
1865
                        pkt.data= bit_buffer;
1866
                        pkt.size= ret;
1867
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1868
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1869
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1870
                    }
1871
                }
1872
            }
1873
        }
1874
    }
1875

    
1876
    return 0;
1877
 fail_decode:
1878
    return -1;
1879
}
1880

    
1881
static void print_sdp(AVFormatContext **avc, int n)
1882
{
1883
    char sdp[2048];
1884

    
1885
    av_sdp_create(avc, n, sdp, sizeof(sdp));
1886
    printf("SDP:\n%s\n", sdp);
1887
    fflush(stdout);
1888
}
1889

    
1890
static int copy_chapters(int infile, int outfile)
1891
{
1892
    AVFormatContext *is = input_files[infile];
1893
    AVFormatContext *os = output_files[outfile];
1894
    int i;
1895

    
1896
    for (i = 0; i < is->nb_chapters; i++) {
1897
        AVChapter *in_ch = is->chapters[i], *out_ch;
1898
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1899
                                      AV_TIME_BASE_Q, in_ch->time_base);
1900
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1901
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1902

    
1903

    
1904
        if (in_ch->end < ts_off)
1905
            continue;
1906
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1907
            break;
1908

    
1909
        out_ch = av_mallocz(sizeof(AVChapter));
1910
        if (!out_ch)
1911
            return AVERROR(ENOMEM);
1912

    
1913
        out_ch->id        = in_ch->id;
1914
        out_ch->time_base = in_ch->time_base;
1915
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1916
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1917

    
1918
        if (metadata_chapters_autocopy)
1919
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1920

    
1921
        os->nb_chapters++;
1922
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1923
        if (!os->chapters)
1924
            return AVERROR(ENOMEM);
1925
        os->chapters[os->nb_chapters - 1] = out_ch;
1926
    }
1927
    return 0;
1928
}
1929

    
1930
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1931
                                    AVCodecContext *avctx)
1932
{
1933
    char *p;
1934
    int n = 1, i;
1935
    int64_t t;
1936

    
1937
    for (p = kf; *p; p++)
1938
        if (*p == ',')
1939
            n++;
1940
    ost->forced_kf_count = n;
1941
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1942
    if (!ost->forced_kf_pts) {
1943
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1944
        ffmpeg_exit(1);
1945
    }
1946
    for (i = 0; i < n; i++) {
1947
        p = i ? strchr(p, ',') + 1 : kf;
1948
        t = parse_time_or_die("force_key_frames", p, 1);
1949
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1950
    }
1951
}
1952

    
1953
/*
1954
 * The following code is the main loop of the file converter
1955
 */
1956
static int transcode(AVFormatContext **output_files,
1957
                     int nb_output_files,
1958
                     AVFormatContext **input_files,
1959
                     int nb_input_files,
1960
                     AVStreamMap *stream_maps, int nb_stream_maps)
1961
{
1962
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0, step;
1963
    AVFormatContext *is, *os;
1964
    AVCodecContext *codec, *icodec;
1965
    AVOutputStream *ost, **ost_table = NULL;
1966
    AVInputStream *ist, **ist_table = NULL;
1967
    AVInputFile *file_table;
1968
    char error[1024];
1969
    int key;
1970
    int want_sdp = 1;
1971
    uint8_t no_packet[MAX_FILES]={0};
1972
    int no_packet_count=0;
1973
    int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
1974
    int nb_streams[AVMEDIA_TYPE_NB]={0};
1975

    
1976
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1977
    if (!file_table)
1978
        goto fail;
1979

    
1980
    /* input stream init */
1981
    j = 0;
1982
    for(i=0;i<nb_input_files;i++) {
1983
        is = input_files[i];
1984
        file_table[i].ist_index = j;
1985
        file_table[i].nb_streams = is->nb_streams;
1986
        j += is->nb_streams;
1987
    }
1988
    nb_istreams = j;
1989

    
1990
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1991
    if (!ist_table)
1992
        goto fail;
1993

    
1994
    for(i=0;i<nb_istreams;i++) {
1995
        ist = av_mallocz(sizeof(AVInputStream));
1996
        if (!ist)
1997
            goto fail;
1998
        ist_table[i] = ist;
1999
    }
2000
    j = 0;
2001
    for(i=0;i<nb_input_files;i++) {
2002
        is = input_files[i];
2003
        for(k=0;k<is->nb_streams;k++) {
2004
            ist = ist_table[j++];
2005
            ist->st = is->streams[k];
2006
            ist->file_index = i;
2007
            ist->index = k;
2008
            ist->discard = 1; /* the stream is discarded by default
2009
                                 (changed later) */
2010

    
2011
            if (rate_emu) {
2012
                ist->start = av_gettime();
2013
            }
2014
        }
2015
    }
2016

    
2017
    /* output stream init */
2018
    nb_ostreams = 0;
2019
    for(i=0;i<nb_output_files;i++) {
2020
        os = output_files[i];
2021
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2022
            av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2023
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2024
            ret = AVERROR(EINVAL);
2025
            goto fail;
2026
        }
2027
        nb_ostreams += os->nb_streams;
2028
    }
2029
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2030
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
2031
        ret = AVERROR(EINVAL);
2032
        goto fail;
2033
    }
2034

    
2035
    /* Sanity check the mapping args -- do the input files & streams exist? */
2036
    for(i=0;i<nb_stream_maps;i++) {
2037
        int fi = stream_maps[i].file_index;
2038
        int si = stream_maps[i].stream_index;
2039

    
2040
        if (fi < 0 || fi > nb_input_files - 1 ||
2041
            si < 0 || si > file_table[fi].nb_streams - 1) {
2042
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2043
            ret = AVERROR(EINVAL);
2044
            goto fail;
2045
        }
2046
        fi = stream_maps[i].sync_file_index;
2047
        si = stream_maps[i].sync_stream_index;
2048
        if (fi < 0 || fi > nb_input_files - 1 ||
2049
            si < 0 || si > file_table[fi].nb_streams - 1) {
2050
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2051
            ret = AVERROR(EINVAL);
2052
            goto fail;
2053
        }
2054
    }
2055

    
2056
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2057
    if (!ost_table)
2058
        goto fail;
2059

    
2060
    for(k=0;k<nb_output_files;k++) {
2061
        os = output_files[k];
2062
        for(i=0;i<os->nb_streams;i++,n++) {
2063
            nb_streams[os->streams[i]->codec->codec_type]++;
2064
        }
2065
    }
2066
    for(step=1<<30; step; step>>=1){
2067
        int found_streams[AVMEDIA_TYPE_NB]={0};
2068
        for(j=0; j<AVMEDIA_TYPE_NB; j++)
2069
            nb_frame_threshold[j] += step;
2070

    
2071
        for(j=0; j<nb_istreams; j++) {
2072
            int skip=0;
2073
            ist = ist_table[j];
2074
            if(opt_programid){
2075
                int pi,si;
2076
                AVFormatContext *f= input_files[ ist->file_index ];
2077
                skip=1;
2078
                for(pi=0; pi<f->nb_programs; pi++){
2079
                    AVProgram *p= f->programs[pi];
2080
                    if(p->id == opt_programid)
2081
                        for(si=0; si<p->nb_stream_indexes; si++){
2082
                            if(f->streams[ p->stream_index[si] ] == ist->st)
2083
                                skip=0;
2084
                        }
2085
                }
2086
            }
2087
            if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
2088
                && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2089
                found_streams[ist->st->codec->codec_type]++;
2090
            }
2091
        }
2092
        for(j=0; j<AVMEDIA_TYPE_NB; j++)
2093
            if(found_streams[j] < nb_streams[j])
2094
                nb_frame_threshold[j] -= step;
2095
    }
2096
    n = 0;
2097
    for(k=0;k<nb_output_files;k++) {
2098
        os = output_files[k];
2099
        for(i=0;i<os->nb_streams;i++,n++) {
2100
            int found;
2101
            ost = ost_table[n] = output_streams_for_file[k][i];
2102
            ost->st = os->streams[i];
2103
            if (nb_stream_maps > 0) {
2104
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2105
                    stream_maps[n].stream_index;
2106

    
2107
                /* Sanity check that the stream types match */
2108
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2109
                    int i= ost->file_index;
2110
                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2111
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2112
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2113
                        ost->file_index, ost->index);
2114
                    ffmpeg_exit(1);
2115
                }
2116

    
2117
            } else {
2118
                /* get corresponding input stream index : we select the first one with the right type */
2119
                found = 0;
2120
                for(j=0;j<nb_istreams;j++) {
2121
                    int skip=0;
2122
                    ist = ist_table[j];
2123
                    if(opt_programid){
2124
                        int pi,si;
2125
                        AVFormatContext *f= input_files[ ist->file_index ];
2126
                        skip=1;
2127
                        for(pi=0; pi<f->nb_programs; pi++){
2128
                            AVProgram *p= f->programs[pi];
2129
                            if(p->id == opt_programid)
2130
                                for(si=0; si<p->nb_stream_indexes; si++){
2131
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2132
                                        skip=0;
2133
                                }
2134
                        }
2135
                    }
2136
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2137
                        ist->st->codec->codec_type == ost->st->codec->codec_type &&
2138
                        nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2139
                            ost->source_index = j;
2140
                            found = 1;
2141
                            break;
2142
                    }
2143
                }
2144

    
2145
                if (!found) {
2146
                    if(! opt_programid) {
2147
                        /* try again and reuse existing stream */
2148
                        for(j=0;j<nb_istreams;j++) {
2149
                            ist = ist_table[j];
2150
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2151
                                && ist->st->discard != AVDISCARD_ALL) {
2152
                                ost->source_index = j;
2153
                                found = 1;
2154
                            }
2155
                        }
2156
                    }
2157
                    if (!found) {
2158
                        int i= ost->file_index;
2159
                        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2160
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2161
                                ost->file_index, ost->index);
2162
                        ffmpeg_exit(1);
2163
                    }
2164
                }
2165
            }
2166
            ist = ist_table[ost->source_index];
2167
            ist->discard = 0;
2168
            ost->sync_ist = (nb_stream_maps > 0) ?
2169
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2170
                         stream_maps[n].sync_stream_index] : ist;
2171
        }
2172
    }
2173

    
2174
    /* for each output stream, we compute the right encoding parameters */
2175
    for(i=0;i<nb_ostreams;i++) {
2176
        ost = ost_table[i];
2177
        os = output_files[ost->file_index];
2178
        ist = ist_table[ost->source_index];
2179

    
2180
        codec = ost->st->codec;
2181
        icodec = ist->st->codec;
2182

    
2183
        if (metadata_streams_autocopy)
2184
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2185
                             AV_METADATA_DONT_OVERWRITE);
2186

    
2187
        ost->st->disposition = ist->st->disposition;
2188
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2189
        codec->chroma_sample_location = icodec->chroma_sample_location;
2190

    
2191
        if (ost->st->stream_copy) {
2192
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2193

    
2194
            if (extra_size > INT_MAX)
2195
                goto fail;
2196

    
2197
            /* if stream_copy is selected, no need to decode or encode */
2198
            codec->codec_id = icodec->codec_id;
2199
            codec->codec_type = icodec->codec_type;
2200

    
2201
            if(!codec->codec_tag){
2202
                if(   !os->oformat->codec_tag
2203
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2204
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2205
                    codec->codec_tag = icodec->codec_tag;
2206
            }
2207

    
2208
            codec->bit_rate = icodec->bit_rate;
2209
            codec->rc_max_rate    = icodec->rc_max_rate;
2210
            codec->rc_buffer_size = icodec->rc_buffer_size;
2211
            codec->extradata= av_mallocz(extra_size);
2212
            if (!codec->extradata)
2213
                goto fail;
2214
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2215
            codec->extradata_size= icodec->extradata_size;
2216
            if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2217
                codec->time_base = icodec->time_base;
2218
                codec->time_base.num *= icodec->ticks_per_frame;
2219
                av_reduce(&codec->time_base.num, &codec->time_base.den,
2220
                          codec->time_base.num, codec->time_base.den, INT_MAX);
2221
            }else
2222
                codec->time_base = ist->st->time_base;
2223
            switch(codec->codec_type) {
2224
            case AVMEDIA_TYPE_AUDIO:
2225
                if(audio_volume != 256) {
2226
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2227
                    ffmpeg_exit(1);
2228
                }
2229
                codec->channel_layout = icodec->channel_layout;
2230
                codec->sample_rate = icodec->sample_rate;
2231
                codec->channels = icodec->channels;
2232
                codec->frame_size = icodec->frame_size;
2233
                codec->audio_service_type = icodec->audio_service_type;
2234
                codec->block_align= icodec->block_align;
2235
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2236
                    codec->block_align= 0;
2237
                if(codec->codec_id == CODEC_ID_AC3)
2238
                    codec->block_align= 0;
2239
                break;
2240
            case AVMEDIA_TYPE_VIDEO:
2241
                codec->pix_fmt = icodec->pix_fmt;
2242
                codec->width = icodec->width;
2243
                codec->height = icodec->height;
2244
                codec->has_b_frames = icodec->has_b_frames;
2245
                if (!codec->sample_aspect_ratio.num) {
2246
                    codec->sample_aspect_ratio =
2247
                    ost->st->sample_aspect_ratio =
2248
                        ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2249
                        ist->st->codec->sample_aspect_ratio.num ?
2250
                        ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2251
                }
2252
                break;
2253
            case AVMEDIA_TYPE_SUBTITLE:
2254
                codec->width = icodec->width;
2255
                codec->height = icodec->height;
2256
                break;
2257
            default:
2258
                abort();
2259
            }
2260
        } else {
2261
            switch(codec->codec_type) {
2262
            case AVMEDIA_TYPE_AUDIO:
2263
                ost->fifo= av_fifo_alloc(1024);
2264
                if(!ost->fifo)
2265
                    goto fail;
2266
                ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2267
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2268
                icodec->request_channels = codec->channels;
2269
                ist->decoding_needed = 1;
2270
                ost->encoding_needed = 1;
2271
                ost->resample_sample_fmt  = icodec->sample_fmt;
2272
                ost->resample_sample_rate = icodec->sample_rate;
2273
                ost->resample_channels    = icodec->channels;
2274
                break;
2275
            case AVMEDIA_TYPE_VIDEO:
2276
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2277
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2278
                    ffmpeg_exit(1);
2279
                }
2280
                ost->video_resample = codec->width   != icodec->width  ||
2281
                                      codec->height  != icodec->height ||
2282
                                      codec->pix_fmt != icodec->pix_fmt;
2283
                if (ost->video_resample) {
2284
#if !CONFIG_AVFILTER
2285
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2286
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2287
                                         codec->width, codec->height)) {
2288
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2289
                        ffmpeg_exit(1);
2290
                    }
2291
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2292
                    ost->img_resample_ctx = sws_getContext(
2293
                        icodec->width,
2294
                        icodec->height,
2295
                            icodec->pix_fmt,
2296
                            codec->width,
2297
                            codec->height,
2298
                            codec->pix_fmt,
2299
                            sws_flags, NULL, NULL, NULL);
2300
                    if (ost->img_resample_ctx == NULL) {
2301
                        fprintf(stderr, "Cannot get resampling context\n");
2302
                        ffmpeg_exit(1);
2303
                    }
2304
#endif
2305
                    codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2306
                }
2307
                ost->resample_height = icodec->height;
2308
                ost->resample_width  = icodec->width;
2309
                ost->resample_pix_fmt= icodec->pix_fmt;
2310
                ost->encoding_needed = 1;
2311
                ist->decoding_needed = 1;
2312

    
2313
#if CONFIG_AVFILTER
2314
                if (configure_video_filters(ist, ost)) {
2315
                    fprintf(stderr, "Error opening filters!\n");
2316
                    exit(1);
2317
                }
2318
#endif
2319
                break;
2320
            case AVMEDIA_TYPE_SUBTITLE:
2321
                ost->encoding_needed = 1;
2322
                ist->decoding_needed = 1;
2323
                break;
2324
            default:
2325
                abort();
2326
                break;
2327
            }
2328
            /* two pass mode */
2329
            if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2330
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2331
                char logfilename[1024];
2332
                FILE *f;
2333

    
2334
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2335
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2336
                         i);
2337
                if (codec->flags & CODEC_FLAG_PASS1) {
2338
                    f = fopen(logfilename, "wb");
2339
                    if (!f) {
2340
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2341
                        ffmpeg_exit(1);
2342
                    }
2343
                    ost->logfile = f;
2344
                } else {
2345
                    char  *logbuffer;
2346
                    size_t logbuffer_size;
2347
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2348
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2349
                        ffmpeg_exit(1);
2350
                    }
2351
                    codec->stats_in = logbuffer;
2352
                }
2353
            }
2354
        }
2355
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2356
            /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2357
            int size= codec->width * codec->height;
2358
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2359
        }
2360
    }
2361

    
2362
    if (!bit_buffer)
2363
        bit_buffer = av_malloc(bit_buffer_size);
2364
    if (!bit_buffer) {
2365
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2366
                bit_buffer_size);
2367
        ret = AVERROR(ENOMEM);
2368
        goto fail;
2369
    }
2370

    
2371
    /* open each encoder */
2372
    for(i=0;i<nb_ostreams;i++) {
2373
        ost = ost_table[i];
2374
        if (ost->encoding_needed) {
2375
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2376
            AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2377
            if (!codec)
2378
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2379
            if (!codec) {
2380
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2381
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2382
                ret = AVERROR(EINVAL);
2383
                goto dump_format;
2384
            }
2385
            if (dec->subtitle_header) {
2386
                ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2387
                if (!ost->st->codec->subtitle_header) {
2388
                    ret = AVERROR(ENOMEM);
2389
                    goto dump_format;
2390
                }
2391
                memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2392
                ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2393
            }
2394
            if (avcodec_open(ost->st->codec, codec) < 0) {
2395
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2396
                        ost->file_index, ost->index);
2397
                ret = AVERROR(EINVAL);
2398
                goto dump_format;
2399
            }
2400
            extra_size += ost->st->codec->extradata_size;
2401
        }
2402
    }
2403

    
2404
    /* open each decoder */
2405
    for(i=0;i<nb_istreams;i++) {
2406
        ist = ist_table[i];
2407
        if (ist->decoding_needed) {
2408
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2409
            if (!codec)
2410
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2411
            if (!codec) {
2412
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2413
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2414
                ret = AVERROR(EINVAL);
2415
                goto dump_format;
2416
            }
2417
            if (avcodec_open(ist->st->codec, codec) < 0) {
2418
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2419
                        ist->file_index, ist->index);
2420
                ret = AVERROR(EINVAL);
2421
                goto dump_format;
2422
            }
2423
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2424
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2425
        }
2426
    }
2427

    
2428
    /* init pts */
2429
    for(i=0;i<nb_istreams;i++) {
2430
        AVStream *st;
2431
        ist = ist_table[i];
2432
        st= ist->st;
2433
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2434
        ist->next_pts = AV_NOPTS_VALUE;
2435
        ist->is_start = 1;
2436
    }
2437

    
2438
    /* set meta data information from input file if required */
2439
    for (i=0;i<nb_meta_data_maps;i++) {
2440
        AVFormatContext *files[2];
2441
        AVMetadata      **meta[2];
2442
        int j;
2443

    
2444
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2445
        if ((index) < 0 || (index) >= (nb_elems)) {\
2446
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2447
                     (desc), (index));\
2448
            ret = AVERROR(EINVAL);\
2449
            goto dump_format;\
2450
        }
2451

    
2452
        int out_file_index = meta_data_maps[i][0].file;
2453
        int in_file_index = meta_data_maps[i][1].file;
2454
        if (in_file_index < 0 || out_file_index < 0)
2455
            continue;
2456
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2457
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2458

    
2459
        files[0] = output_files[out_file_index];
2460
        files[1] = input_files[in_file_index];
2461

    
2462
        for (j = 0; j < 2; j++) {
2463
            AVMetaDataMap *map = &meta_data_maps[i][j];
2464

    
2465
            switch (map->type) {
2466
            case 'g':
2467
                meta[j] = &files[j]->metadata;
2468
                break;
2469
            case 's':
2470
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2471
                meta[j] = &files[j]->streams[map->index]->metadata;
2472
                break;
2473
            case 'c':
2474
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2475
                meta[j] = &files[j]->chapters[map->index]->metadata;
2476
                break;
2477
            case 'p':
2478
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2479
                meta[j] = &files[j]->programs[map->index]->metadata;
2480
                break;
2481
            }
2482
        }
2483

    
2484
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2485
    }
2486

    
2487
    /* copy global metadata by default */
2488
    if (metadata_global_autocopy) {
2489

    
2490
        for (i = 0; i < nb_output_files; i++)
2491
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2492
                             AV_METADATA_DONT_OVERWRITE);
2493
    }
2494

    
2495
    /* copy chapters according to chapter maps */
2496
    for (i = 0; i < nb_chapter_maps; i++) {
2497
        int infile  = chapter_maps[i].in_file;
2498
        int outfile = chapter_maps[i].out_file;
2499

    
2500
        if (infile < 0 || outfile < 0)
2501
            continue;
2502
        if (infile >= nb_input_files) {
2503
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2504
            ret = AVERROR(EINVAL);
2505
            goto dump_format;
2506
        }
2507
        if (outfile >= nb_output_files) {
2508
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2509
            ret = AVERROR(EINVAL);
2510
            goto dump_format;
2511
        }
2512
        copy_chapters(infile, outfile);
2513
    }
2514

    
2515
    /* copy chapters from the first input file that has them*/
2516
    if (!nb_chapter_maps)
2517
        for (i = 0; i < nb_input_files; i++) {
2518
            if (!input_files[i]->nb_chapters)
2519
                continue;
2520

    
2521
            for (j = 0; j < nb_output_files; j++)
2522
                if ((ret = copy_chapters(i, j)) < 0)
2523
                    goto dump_format;
2524
            break;
2525
        }
2526

    
2527
    /* open files and write file headers */
2528
    for(i=0;i<nb_output_files;i++) {
2529
        os = output_files[i];
2530
        if (av_write_header(os) < 0) {
2531
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2532
            ret = AVERROR(EINVAL);
2533
            goto dump_format;
2534
        }
2535
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2536
            want_sdp = 0;
2537
        }
2538
    }
2539

    
2540
 dump_format:
2541
    /* dump the file output parameters - cannot be done before in case
2542
       of stream copy */
2543
    for(i=0;i<nb_output_files;i++) {
2544
        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2545
    }
2546

    
2547
    /* dump the stream mapping */
2548
    if (verbose >= 0) {
2549
        fprintf(stderr, "Stream mapping:\n");
2550
        for(i=0;i<nb_ostreams;i++) {
2551
            ost = ost_table[i];
2552
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2553
                    ist_table[ost->source_index]->file_index,
2554
                    ist_table[ost->source_index]->index,
2555
                    ost->file_index,
2556
                    ost->index);
2557
            if (ost->sync_ist != ist_table[ost->source_index])
2558
                fprintf(stderr, " [sync #%d.%d]",
2559
                        ost->sync_ist->file_index,
2560
                        ost->sync_ist->index);
2561
            fprintf(stderr, "\n");
2562
        }
2563
    }
2564

    
2565
    if (ret) {
2566
        fprintf(stderr, "%s\n", error);
2567
        goto fail;
2568
    }
2569

    
2570
    if (want_sdp) {
2571
        print_sdp(output_files, nb_output_files);
2572
    }
2573

    
2574
    if (!using_stdin) {
2575
        if(verbose >= 0)
2576
            fprintf(stderr, "Press [q] to stop encoding\n");
2577
        avio_set_interrupt_cb(decode_interrupt_cb);
2578
    }
2579
    term_init();
2580

    
2581
    timer_start = av_gettime();
2582

    
2583
    for(; received_sigterm == 0;) {
2584
        int file_index, ist_index;
2585
        AVPacket pkt;
2586
        double ipts_min;
2587
        double opts_min;
2588

    
2589
    redo:
2590
        ipts_min= 1e100;
2591
        opts_min= 1e100;
2592
        /* if 'q' pressed, exits */
2593
        if (!using_stdin) {
2594
            if (q_pressed)
2595
                break;
2596
            /* read_key() returns 0 on EOF */
2597
            key = read_key();
2598
            if (key == 'q')
2599
                break;
2600
        }
2601

    
2602
        /* select the stream that we must read now by looking at the
2603
           smallest output pts */
2604
        file_index = -1;
2605
        for(i=0;i<nb_ostreams;i++) {
2606
            double ipts, opts;
2607
            ost = ost_table[i];
2608
            os = output_files[ost->file_index];
2609
            ist = ist_table[ost->source_index];
2610
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2611
                continue;
2612
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2613
            ipts = (double)ist->pts;
2614
            if (!file_table[ist->file_index].eof_reached){
2615
                if(ipts < ipts_min) {
2616
                    ipts_min = ipts;
2617
                    if(input_sync ) file_index = ist->file_index;
2618
                }
2619
                if(opts < opts_min) {
2620
                    opts_min = opts;
2621
                    if(!input_sync) file_index = ist->file_index;
2622
                }
2623
            }
2624
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2625
                file_index= -1;
2626
                break;
2627
            }
2628
        }
2629
        /* if none, if is finished */
2630
        if (file_index < 0) {
2631
            if(no_packet_count){
2632
                no_packet_count=0;
2633
                memset(no_packet, 0, sizeof(no_packet));
2634
                usleep(10000);
2635
                continue;
2636
            }
2637
            break;
2638
        }
2639

    
2640
        /* finish if limit size exhausted */
2641
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2642
            break;
2643

    
2644
        /* read a frame from it and output it in the fifo */
2645
        is = input_files[file_index];
2646
        ret= av_read_frame(is, &pkt);
2647
        if(ret == AVERROR(EAGAIN)){
2648
            no_packet[file_index]=1;
2649
            no_packet_count++;
2650
            continue;
2651
        }
2652
        if (ret < 0) {
2653
            file_table[file_index].eof_reached = 1;
2654
            if (opt_shortest)
2655
                break;
2656
            else
2657
                continue;
2658
        }
2659

    
2660
        no_packet_count=0;
2661
        memset(no_packet, 0, sizeof(no_packet));
2662

    
2663
        if (do_pkt_dump) {
2664
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2665
                             is->streams[pkt.stream_index]);
2666
        }
2667
        /* the following test is needed in case new streams appear
2668
           dynamically in stream : we ignore them */
2669
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2670
            goto discard_packet;
2671
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2672
        ist = ist_table[ist_index];
2673
        if (ist->discard)
2674
            goto discard_packet;
2675

    
2676
        if (pkt.dts != AV_NOPTS_VALUE)
2677
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2678
        if (pkt.pts != AV_NOPTS_VALUE)
2679
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2680

    
2681
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2682
            && input_files_ts_scale[file_index][pkt.stream_index]){
2683
            if(pkt.pts != AV_NOPTS_VALUE)
2684
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2685
            if(pkt.dts != AV_NOPTS_VALUE)
2686
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2687
        }
2688

    
2689
//        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);
2690
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2691
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2692
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2693
            int64_t delta= pkt_dts - ist->next_pts;
2694
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2695
                input_files_ts_offset[ist->file_index]-= delta;
2696
                if (verbose > 2)
2697
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2698
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2699
                if(pkt.pts != AV_NOPTS_VALUE)
2700
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2701
            }
2702
        }
2703

    
2704
        /* finish if recording time exhausted */
2705
        if (recording_time != INT64_MAX &&
2706
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2707
            ist->is_past_recording_time = 1;
2708
            goto discard_packet;
2709
        }
2710

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

    
2714
            if (verbose >= 0)
2715
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2716
                        ist->file_index, ist->index);
2717
            if (exit_on_error)
2718
                ffmpeg_exit(1);
2719
            av_free_packet(&pkt);
2720
            goto redo;
2721
        }
2722

    
2723
    discard_packet:
2724
        av_free_packet(&pkt);
2725

    
2726
        /* dump report by using the output first video and audio streams */
2727
        print_report(output_files, ost_table, nb_ostreams, 0);
2728
    }
2729

    
2730
    /* at the end of stream, we must flush the decoder buffers */
2731
    for(i=0;i<nb_istreams;i++) {
2732
        ist = ist_table[i];
2733
        if (ist->decoding_needed) {
2734
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2735
        }
2736
    }
2737

    
2738
    term_exit();
2739

    
2740
    /* write the trailer if needed and close file */
2741
    for(i=0;i<nb_output_files;i++) {
2742
        os = output_files[i];
2743
        av_write_trailer(os);
2744
    }
2745

    
2746
    /* dump report by using the first video and audio streams */
2747
    print_report(output_files, ost_table, nb_ostreams, 1);
2748

    
2749
    /* close each encoder */
2750
    for(i=0;i<nb_ostreams;i++) {
2751
        ost = ost_table[i];
2752
        if (ost->encoding_needed) {
2753
            av_freep(&ost->st->codec->stats_in);
2754
            avcodec_close(ost->st->codec);
2755
        }
2756
#if CONFIG_AVFILTER
2757
        avfilter_graph_free(&ost->graph);
2758
#endif
2759
    }
2760

    
2761
    /* close each decoder */
2762
    for(i=0;i<nb_istreams;i++) {
2763
        ist = ist_table[i];
2764
        if (ist->decoding_needed) {
2765
            avcodec_close(ist->st->codec);
2766
        }
2767
    }
2768

    
2769
    /* finished ! */
2770
    ret = 0;
2771

    
2772
 fail:
2773
    av_freep(&bit_buffer);
2774
    av_free(file_table);
2775

    
2776
    if (ist_table) {
2777
        for(i=0;i<nb_istreams;i++) {
2778
            ist = ist_table[i];
2779
            av_free(ist);
2780
        }
2781
        av_free(ist_table);
2782
    }
2783
    if (ost_table) {
2784
        for(i=0;i<nb_ostreams;i++) {
2785
            ost = ost_table[i];
2786
            if (ost) {
2787
                if (ost->st->stream_copy)
2788
                    av_freep(&ost->st->codec->extradata);
2789
                if (ost->logfile) {
2790
                    fclose(ost->logfile);
2791
                    ost->logfile = NULL;
2792
                }
2793
                av_fifo_free(ost->fifo); /* works even if fifo is not
2794
                                             initialized but set to zero */
2795
                av_freep(&ost->st->codec->subtitle_header);
2796
                av_free(ost->pict_tmp.data[0]);
2797
                av_free(ost->forced_kf_pts);
2798
                if (ost->video_resample)
2799
                    sws_freeContext(ost->img_resample_ctx);
2800
                if (ost->resample)
2801
                    audio_resample_close(ost->resample);
2802
                if (ost->reformat_ctx)
2803
                    av_audio_convert_free(ost->reformat_ctx);
2804
                av_free(ost);
2805
            }
2806
        }
2807
        av_free(ost_table);
2808
    }
2809
    return ret;
2810
}
2811

    
2812
static void opt_format(const char *arg)
2813
{
2814
    last_asked_format = arg;
2815
}
2816

    
2817
static void opt_video_rc_override_string(const char *arg)
2818
{
2819
    video_rc_override_string = arg;
2820
}
2821

    
2822
static int opt_me_threshold(const char *opt, const char *arg)
2823
{
2824
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2825
    return 0;
2826
}
2827

    
2828
static int opt_verbose(const char *opt, const char *arg)
2829
{
2830
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2831
    return 0;
2832
}
2833

    
2834
static int opt_frame_rate(const char *opt, const char *arg)
2835
{
2836
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2837
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2838
        ffmpeg_exit(1);
2839
    }
2840
    return 0;
2841
}
2842

    
2843
static int opt_bitrate(const char *opt, const char *arg)
2844
{
2845
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2846

    
2847
    opt_default(opt, arg);
2848

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

    
2852
    return 0;
2853
}
2854

    
2855
static int opt_frame_crop(const char *opt, const char *arg)
2856
{
2857
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2858
    return AVERROR(EINVAL);
2859
}
2860

    
2861
static void opt_frame_size(const char *arg)
2862
{
2863
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2864
        fprintf(stderr, "Incorrect frame size\n");
2865
        ffmpeg_exit(1);
2866
    }
2867
}
2868

    
2869
static int opt_pad(const char *opt, const char *arg) {
2870
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2871
    return -1;
2872
}
2873

    
2874
static void opt_frame_pix_fmt(const char *arg)
2875
{
2876
    if (strcmp(arg, "list")) {
2877
        frame_pix_fmt = av_get_pix_fmt(arg);
2878
        if (frame_pix_fmt == PIX_FMT_NONE) {
2879
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2880
            ffmpeg_exit(1);
2881
        }
2882
    } else {
2883
        show_pix_fmts();
2884
        ffmpeg_exit(0);
2885
    }
2886
}
2887

    
2888
static void opt_frame_aspect_ratio(const char *arg)
2889
{
2890
    int x = 0, y = 0;
2891
    double ar = 0;
2892
    const char *p;
2893
    char *end;
2894

    
2895
    p = strchr(arg, ':');
2896
    if (p) {
2897
        x = strtol(arg, &end, 10);
2898
        if (end == p)
2899
            y = strtol(end+1, &end, 10);
2900
        if (x > 0 && y > 0)
2901
            ar = (double)x / (double)y;
2902
    } else
2903
        ar = strtod(arg, NULL);
2904

    
2905
    if (!ar) {
2906
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2907
        ffmpeg_exit(1);
2908
    }
2909
    frame_aspect_ratio = ar;
2910
}
2911

    
2912
static int opt_metadata(const char *opt, const char *arg)
2913
{
2914
    char *mid= strchr(arg, '=');
2915

    
2916
    if(!mid){
2917
        fprintf(stderr, "Missing =\n");
2918
        ffmpeg_exit(1);
2919
    }
2920
    *mid++= 0;
2921

    
2922
    av_metadata_set2(&metadata, arg, mid, 0);
2923

    
2924
    return 0;
2925
}
2926

    
2927
static int opt_qscale(const char *opt, const char *arg)
2928
{
2929
    video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2930
    if (video_qscale <= 0 || video_qscale > 255) {
2931
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2932
        return AVERROR(EINVAL);
2933
    }
2934
    return 0;
2935
}
2936

    
2937
static int opt_top_field_first(const char *opt, const char *arg)
2938
{
2939
    top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2940
    return 0;
2941
}
2942

    
2943
static int opt_thread_count(const char *opt, const char *arg)
2944
{
2945
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2946
#if !HAVE_THREADS
2947
    if (verbose >= 0)
2948
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2949
#endif
2950
    return 0;
2951
}
2952

    
2953
static void opt_audio_sample_fmt(const char *arg)
2954
{
2955
    if (strcmp(arg, "list")) {
2956
        audio_sample_fmt = av_get_sample_fmt(arg);
2957
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2958
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2959
            ffmpeg_exit(1);
2960
        }
2961
    } else {
2962
        int i;
2963
        char fmt_str[128];
2964
        for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2965
            printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2966
        ffmpeg_exit(0);
2967
    }
2968
}
2969

    
2970
static int opt_audio_rate(const char *opt, const char *arg)
2971
{
2972
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2973
    return 0;
2974
}
2975

    
2976
static int opt_audio_channels(const char *opt, const char *arg)
2977
{
2978
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2979
    return 0;
2980
}
2981

    
2982
static int opt_video_channel(const char *opt, const char *arg)
2983
{
2984
    video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2985
    return 0;
2986
}
2987

    
2988
static void opt_video_standard(const char *arg)
2989
{
2990
    video_standard = av_strdup(arg);
2991
}
2992

    
2993
static void opt_codec(int *pstream_copy, char **pcodec_name,
2994
                      int codec_type, const char *arg)
2995
{
2996
    av_freep(pcodec_name);
2997
    if (!strcmp(arg, "copy")) {
2998
        *pstream_copy = 1;
2999
    } else {
3000
        *pcodec_name = av_strdup(arg);
3001
    }
3002
}
3003

    
3004
static void opt_audio_codec(const char *arg)
3005
{
3006
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
3007
}
3008

    
3009
static void opt_video_codec(const char *arg)
3010
{
3011
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
3012
}
3013

    
3014
static void opt_subtitle_codec(const char *arg)
3015
{
3016
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3017
}
3018

    
3019
static int opt_codec_tag(const char *opt, const char *arg)
3020
{
3021
    char *tail;
3022
    uint32_t *codec_tag;
3023

    
3024
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3025
                !strcmp(opt, "vtag") ? &video_codec_tag :
3026
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3027
    if (!codec_tag)
3028
        return -1;
3029

    
3030
    *codec_tag = strtol(arg, &tail, 0);
3031
    if (!tail || *tail)
3032
        *codec_tag = AV_RL32(arg);
3033

    
3034
    return 0;
3035
}
3036

    
3037
static void opt_map(const char *arg)
3038
{
3039
    AVStreamMap *m;
3040
    char *p;
3041

    
3042
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3043
    m = &stream_maps[nb_stream_maps-1];
3044

    
3045
    m->file_index = strtol(arg, &p, 0);
3046
    if (*p)
3047
        p++;
3048

    
3049
    m->stream_index = strtol(p, &p, 0);
3050
    if (*p) {
3051
        p++;
3052
        m->sync_file_index = strtol(p, &p, 0);
3053
        if (*p)
3054
            p++;
3055
        m->sync_stream_index = strtol(p, &p, 0);
3056
    } else {
3057
        m->sync_file_index = m->file_index;
3058
        m->sync_stream_index = m->stream_index;
3059
    }
3060
}
3061

    
3062
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3063
{
3064
    *endptr = arg;
3065
    if (*arg == ',') {
3066
        *type = *(++arg);
3067
        switch (*arg) {
3068
        case 'g':
3069
            break;
3070
        case 's':
3071
        case 'c':
3072
        case 'p':
3073
            *index = strtol(++arg, endptr, 0);
3074
            break;
3075
        default:
3076
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3077
            ffmpeg_exit(1);
3078
        }
3079
    } else
3080
        *type = 'g';
3081
}
3082

    
3083
static void opt_map_metadata(const char *arg)
3084
{
3085
    AVMetaDataMap *m, *m1;
3086
    char *p;
3087

    
3088
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3089
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3090

    
3091
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3092
    m->file = strtol(arg, &p, 0);
3093
    parse_meta_type(p, &m->type, &m->index, &p);
3094
    if (*p)
3095
        p++;
3096

    
3097
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3098
    m1->file = strtol(p, &p, 0);
3099
    parse_meta_type(p, &m1->type, &m1->index, &p);
3100

    
3101
    if (m->type == 'g' || m1->type == 'g')
3102
        metadata_global_autocopy = 0;
3103
    if (m->type == 's' || m1->type == 's')
3104
        metadata_streams_autocopy = 0;
3105
    if (m->type == 'c' || m1->type == 'c')
3106
        metadata_chapters_autocopy = 0;
3107
}
3108

    
3109
static void opt_map_meta_data(const char *arg)
3110
{
3111
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3112
                    "Use -map_metadata instead.\n");
3113
    opt_map_metadata(arg);
3114
}
3115

    
3116
static void opt_map_chapters(const char *arg)
3117
{
3118
    AVChapterMap *c;
3119
    char *p;
3120

    
3121
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3122
                              nb_chapter_maps + 1);
3123
    c = &chapter_maps[nb_chapter_maps - 1];
3124
    c->out_file = strtol(arg, &p, 0);
3125
    if (*p)
3126
        p++;
3127

    
3128
    c->in_file = strtol(p, &p, 0);
3129
}
3130

    
3131
static void opt_input_ts_scale(const char *arg)
3132
{
3133
    unsigned int stream;
3134
    double scale;
3135
    char *p;
3136

    
3137
    stream = strtol(arg, &p, 0);
3138
    if (*p)
3139
        p++;
3140
    scale= strtod(p, &p);
3141

    
3142
    if(stream >= MAX_STREAMS)
3143
        ffmpeg_exit(1);
3144

    
3145
    input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);
3146
    input_files_ts_scale[nb_input_files][stream]= scale;
3147
}
3148

    
3149
static int opt_recording_time(const char *opt, const char *arg)
3150
{
3151
    recording_time = parse_time_or_die(opt, arg, 1);
3152
    return 0;
3153
}
3154

    
3155
static int opt_start_time(const char *opt, const char *arg)
3156
{
3157
    start_time = parse_time_or_die(opt, arg, 1);
3158
    return 0;
3159
}
3160

    
3161
static int opt_recording_timestamp(const char *opt, const char *arg)
3162
{
3163
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3164
    return 0;
3165
}
3166

    
3167
static int opt_input_ts_offset(const char *opt, const char *arg)
3168
{
3169
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3170
    return 0;
3171
}
3172

    
3173
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3174
{
3175
    const char *codec_string = encoder ? "encoder" : "decoder";
3176
    AVCodec *codec;
3177

    
3178
    if(!name)
3179
        return CODEC_ID_NONE;
3180
    codec = encoder ?
3181
        avcodec_find_encoder_by_name(name) :
3182
        avcodec_find_decoder_by_name(name);
3183
    if(!codec) {
3184
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3185
        ffmpeg_exit(1);
3186
    }
3187
    if(codec->type != type) {
3188
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3189
        ffmpeg_exit(1);
3190
    }
3191
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3192
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3193
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3194
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3195
                codec_string, codec->name);
3196
        codec = encoder ?
3197
            avcodec_find_encoder(codec->id) :
3198
            avcodec_find_decoder(codec->id);
3199
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3200
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3201
                    codec_string, codec->name);
3202
        ffmpeg_exit(1);
3203
    }
3204
    return codec->id;
3205
}
3206

    
3207
static void opt_input_file(const char *filename)
3208
{
3209
    AVFormatContext *ic;
3210
    AVFormatParameters params, *ap = &params;
3211
    AVInputFormat *file_iformat = NULL;
3212
    int err, i, ret, rfps, rfps_base;
3213
    int64_t timestamp;
3214

    
3215
    if (last_asked_format) {
3216
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3217
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3218
            ffmpeg_exit(1);
3219
        }
3220
        last_asked_format = NULL;
3221
    }
3222

    
3223
    if (!strcmp(filename, "-"))
3224
        filename = "pipe:";
3225

    
3226
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3227
                    !strcmp(filename, "/dev/stdin");
3228

    
3229
    /* get default parameters from command line */
3230
    ic = avformat_alloc_context();
3231
    if (!ic) {
3232
        print_error(filename, AVERROR(ENOMEM));
3233
        ffmpeg_exit(1);
3234
    }
3235

    
3236
    memset(ap, 0, sizeof(*ap));
3237
    ap->prealloced_context = 1;
3238
    ap->sample_rate = audio_sample_rate;
3239
    ap->channels = audio_channels;
3240
    ap->time_base.den = frame_rate.num;
3241
    ap->time_base.num = frame_rate.den;
3242
    ap->width = frame_width;
3243
    ap->height = frame_height;
3244
    ap->pix_fmt = frame_pix_fmt;
3245
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3246
    ap->channel = video_channel;
3247
    ap->standard = video_standard;
3248

    
3249
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3250

    
3251
    ic->video_codec_id   =
3252
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3253
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3254
    ic->audio_codec_id   =
3255
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3256
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3257
    ic->subtitle_codec_id=
3258
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3259
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3260
    ic->flags |= AVFMT_FLAG_NONBLOCK | AVFMT_FLAG_PRIV_OPT;
3261

    
3262
    /* open the input file with generic libav function */
3263
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3264
    if(err >= 0){
3265
        set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3266
        err = av_demuxer_open(ic, ap);
3267
        if(err < 0)
3268
            avformat_free_context(ic);
3269
    }
3270
    if (err < 0) {
3271
        print_error(filename, err);
3272
        ffmpeg_exit(1);
3273
    }
3274
    if(opt_programid) {
3275
        int i, j;
3276
        int found=0;
3277
        for(i=0; i<ic->nb_streams; i++){
3278
            ic->streams[i]->discard= AVDISCARD_ALL;
3279
        }
3280
        for(i=0; i<ic->nb_programs; i++){
3281
            AVProgram *p= ic->programs[i];
3282
            if(p->id != opt_programid){
3283
                p->discard = AVDISCARD_ALL;
3284
            }else{
3285
                found=1;
3286
                for(j=0; j<p->nb_stream_indexes; j++){
3287
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3288
                }
3289
            }
3290
        }
3291
        if(!found){
3292
            fprintf(stderr, "Specified program id not found\n");
3293
            ffmpeg_exit(1);
3294
        }
3295
        opt_programid=0;
3296
    }
3297

    
3298
    ic->loop_input = loop_input;
3299

    
3300
    /* If not enough info to get the stream parameters, we decode the
3301
       first frames to get it. (used in mpeg case for example) */
3302
    ret = av_find_stream_info(ic);
3303
    if (ret < 0 && verbose >= 0) {
3304
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3305
        av_close_input_file(ic);
3306
        ffmpeg_exit(1);
3307
    }
3308

    
3309
    timestamp = start_time;
3310
    /* add the stream start time */
3311
    if (ic->start_time != AV_NOPTS_VALUE)
3312
        timestamp += ic->start_time;
3313

    
3314
    /* if seeking requested, we execute it */
3315
    if (start_time != 0) {
3316
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3317
        if (ret < 0) {
3318
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3319
                    filename, (double)timestamp / AV_TIME_BASE);
3320
        }
3321
        /* reset seek info */
3322
        start_time = 0;
3323
    }
3324

    
3325
    /* update the current parameters so that they match the one of the input stream */
3326
    for(i=0;i<ic->nb_streams;i++) {
3327
        AVStream *st = ic->streams[i];
3328
        AVCodecContext *dec = st->codec;
3329
        dec->thread_count = thread_count;
3330
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3331
        switch (dec->codec_type) {
3332
        case AVMEDIA_TYPE_AUDIO:
3333
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3334
            set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3335
            channel_layout    = dec->channel_layout;
3336
            audio_channels    = dec->channels;
3337
            audio_sample_rate = dec->sample_rate;
3338
            audio_sample_fmt  = dec->sample_fmt;
3339
            if(audio_disable)
3340
                st->discard= AVDISCARD_ALL;
3341
            /* Note that av_find_stream_info can add more streams, and we
3342
             * currently have no chance of setting up lowres decoding
3343
             * early enough for them. */
3344
            if (dec->lowres)
3345
                audio_sample_rate >>= dec->lowres;
3346
            break;
3347
        case AVMEDIA_TYPE_VIDEO:
3348
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3349
            set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3350
            frame_height = dec->height;
3351
            frame_width  = dec->width;
3352
            frame_pix_fmt = dec->pix_fmt;
3353
            rfps      = ic->streams[i]->r_frame_rate.num;
3354
            rfps_base = ic->streams[i]->r_frame_rate.den;
3355
            if (dec->lowres) {
3356
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3357
                frame_height >>= dec->lowres;
3358
                frame_width  >>= dec->lowres;
3359
                dec->height = frame_height;
3360
                dec->width  = frame_width;
3361
            }
3362
            if(me_threshold)
3363
                dec->debug |= FF_DEBUG_MV;
3364

    
3365
            if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3366

    
3367
                if (verbose >= 0)
3368
                    fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3369
                            i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3370

    
3371
                    (float)rfps / rfps_base, rfps, rfps_base);
3372
            }
3373
            /* update the current frame rate to match the stream frame rate */
3374
            frame_rate.num = rfps;
3375
            frame_rate.den = rfps_base;
3376

    
3377
            if(video_disable)
3378
                st->discard= AVDISCARD_ALL;
3379
            else if(video_discard)
3380
                st->discard= video_discard;
3381
            break;
3382
        case AVMEDIA_TYPE_DATA:
3383
            break;
3384
        case AVMEDIA_TYPE_SUBTITLE:
3385
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3386
            if(subtitle_disable)
3387
                st->discard = AVDISCARD_ALL;
3388
            break;
3389
        case AVMEDIA_TYPE_ATTACHMENT:
3390
        case AVMEDIA_TYPE_UNKNOWN:
3391
            break;
3392
        default:
3393
            abort();
3394
        }
3395
    }
3396

    
3397
    input_files[nb_input_files] = ic;
3398
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3399
    /* dump the file content */
3400
    if (verbose >= 0)
3401
        av_dump_format(ic, nb_input_files, filename, 0);
3402

    
3403
    nb_input_files++;
3404

    
3405
    video_channel = 0;
3406

    
3407
    av_freep(&video_codec_name);
3408
    av_freep(&audio_codec_name);
3409
    av_freep(&subtitle_codec_name);
3410
}
3411

    
3412
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3413
                                         int *has_subtitle_ptr)
3414
{
3415
    int has_video, has_audio, has_subtitle, i, j;
3416
    AVFormatContext *ic;
3417

    
3418
    has_video = 0;
3419
    has_audio = 0;
3420
    has_subtitle = 0;
3421
    for(j=0;j<nb_input_files;j++) {
3422
        ic = input_files[j];
3423
        for(i=0;i<ic->nb_streams;i++) {
3424
            AVCodecContext *enc = ic->streams[i]->codec;
3425
            switch(enc->codec_type) {
3426
            case AVMEDIA_TYPE_AUDIO:
3427
                has_audio = 1;
3428
                break;
3429
            case AVMEDIA_TYPE_VIDEO:
3430
                has_video = 1;
3431
                break;
3432
            case AVMEDIA_TYPE_SUBTITLE:
3433
                has_subtitle = 1;
3434
                break;
3435
            case AVMEDIA_TYPE_DATA:
3436
            case AVMEDIA_TYPE_ATTACHMENT:
3437
            case AVMEDIA_TYPE_UNKNOWN:
3438
                break;
3439
            default:
3440
                abort();
3441
            }
3442
        }
3443
    }
3444
    *has_video_ptr = has_video;
3445
    *has_audio_ptr = has_audio;
3446
    *has_subtitle_ptr = has_subtitle;
3447
}
3448

    
3449
static void new_video_stream(AVFormatContext *oc, int file_idx)
3450
{
3451
    AVStream *st;
3452
    AVOutputStream *ost;
3453
    AVCodecContext *video_enc;
3454
    enum CodecID codec_id = CODEC_ID_NONE;
3455
    AVCodec *codec= NULL;
3456

    
3457
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3458
    if (!st) {
3459
        fprintf(stderr, "Could not alloc stream\n");
3460
        ffmpeg_exit(1);
3461
    }
3462
    ost = new_output_stream(oc, file_idx);
3463

    
3464
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3465
    if(!video_stream_copy){
3466
        if (video_codec_name) {
3467
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3468
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3469
            codec = avcodec_find_encoder_by_name(video_codec_name);
3470
            output_codecs[nb_output_codecs-1] = codec;
3471
        } else {
3472
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3473
            codec = avcodec_find_encoder(codec_id);
3474
        }
3475
        ost->frame_aspect_ratio = frame_aspect_ratio;
3476
        frame_aspect_ratio = 0;
3477
#if CONFIG_AVFILTER
3478
        ost->avfilter= vfilters;
3479
        vfilters= NULL;
3480
#endif
3481
    }
3482

    
3483
    avcodec_get_context_defaults3(st->codec, codec);
3484
    ost->bitstream_filters = video_bitstream_filters;
3485
    video_bitstream_filters= NULL;
3486

    
3487
    st->codec->thread_count= thread_count;
3488

    
3489
    video_enc = st->codec;
3490

    
3491
    if(video_codec_tag)
3492
        video_enc->codec_tag= video_codec_tag;
3493

    
3494
    if(   (video_global_header&1)
3495
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3496
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3497
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3498
    }
3499
    if(video_global_header&2){
3500
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3501
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3502
    }
3503

    
3504
    if (video_stream_copy) {
3505
        st->stream_copy = 1;
3506
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3507
        video_enc->sample_aspect_ratio =
3508
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3509
    } else {
3510
        const char *p;
3511
        int i;
3512
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3513

    
3514
        video_enc->codec_id = codec_id;
3515
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3516

    
3517
        if (codec && codec->supported_framerates && !force_fps)
3518
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3519
        video_enc->time_base.den = fps.num;
3520
        video_enc->time_base.num = fps.den;
3521

    
3522
        video_enc->width = frame_width;
3523
        video_enc->height = frame_height;
3524
        video_enc->pix_fmt = frame_pix_fmt;
3525
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3526
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3527

    
3528
        choose_pixel_fmt(st, codec);
3529

    
3530
        if (intra_only)
3531
            video_enc->gop_size = 0;
3532
        if (video_qscale || same_quality) {
3533
            video_enc->flags |= CODEC_FLAG_QSCALE;
3534
            video_enc->global_quality=
3535
                st->quality = FF_QP2LAMBDA * video_qscale;
3536
        }
3537

    
3538
        if(intra_matrix)
3539
            video_enc->intra_matrix = intra_matrix;
3540
        if(inter_matrix)
3541
            video_enc->inter_matrix = inter_matrix;
3542

    
3543
        p= video_rc_override_string;
3544
        for(i=0; p; i++){
3545
            int start, end, q;
3546
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3547
            if(e!=3){
3548
                fprintf(stderr, "error parsing rc_override\n");
3549
                ffmpeg_exit(1);
3550
            }
3551
            video_enc->rc_override=
3552
                av_realloc(video_enc->rc_override,
3553
                           sizeof(RcOverride)*(i+1));
3554
            video_enc->rc_override[i].start_frame= start;
3555
            video_enc->rc_override[i].end_frame  = end;
3556
            if(q>0){
3557
                video_enc->rc_override[i].qscale= q;
3558
                video_enc->rc_override[i].quality_factor= 1.0;
3559
            }
3560
            else{
3561
                video_enc->rc_override[i].qscale= 0;
3562
                video_enc->rc_override[i].quality_factor= -q/100.0;
3563
            }
3564
            p= strchr(p, '/');
3565
            if(p) p++;
3566
        }
3567
        video_enc->rc_override_count=i;
3568
        if (!video_enc->rc_initial_buffer_occupancy)
3569
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3570
        video_enc->me_threshold= me_threshold;
3571
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3572

    
3573
        if (do_psnr)
3574
            video_enc->flags|= CODEC_FLAG_PSNR;
3575

    
3576
        /* two pass mode */
3577
        if (do_pass) {
3578
            if (do_pass == 1) {
3579
                video_enc->flags |= CODEC_FLAG_PASS1;
3580
            } else {
3581
                video_enc->flags |= CODEC_FLAG_PASS2;
3582
            }
3583
        }
3584

    
3585
        if (forced_key_frames)
3586
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3587
    }
3588
    if (video_language) {
3589
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3590
        av_freep(&video_language);
3591
    }
3592

    
3593
    /* reset some key parameters */
3594
    video_disable = 0;
3595
    av_freep(&video_codec_name);
3596
    av_freep(&forced_key_frames);
3597
    video_stream_copy = 0;
3598
    frame_pix_fmt = PIX_FMT_NONE;
3599
}
3600

    
3601
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3602
{
3603
    AVStream *st;
3604
    AVOutputStream *ost;
3605
    AVCodec *codec= NULL;
3606
    AVCodecContext *audio_enc;
3607
    enum CodecID codec_id = CODEC_ID_NONE;
3608

    
3609
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3610
    if (!st) {
3611
        fprintf(stderr, "Could not alloc stream\n");
3612
        ffmpeg_exit(1);
3613
    }
3614
    ost = new_output_stream(oc, file_idx);
3615

    
3616
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3617
    if(!audio_stream_copy){
3618
        if (audio_codec_name) {
3619
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3620
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3621
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3622
            output_codecs[nb_output_codecs-1] = codec;
3623
        } else {
3624
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3625
            codec = avcodec_find_encoder(codec_id);
3626
        }
3627
    }
3628

    
3629
    avcodec_get_context_defaults3(st->codec, codec);
3630

    
3631
    ost->bitstream_filters = audio_bitstream_filters;
3632
    audio_bitstream_filters= NULL;
3633

    
3634
    st->codec->thread_count= thread_count;
3635

    
3636
    audio_enc = st->codec;
3637
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3638

    
3639
    if(audio_codec_tag)
3640
        audio_enc->codec_tag= audio_codec_tag;
3641

    
3642
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3643
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3644
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3645
    }
3646
    if (audio_stream_copy) {
3647
        st->stream_copy = 1;
3648
        audio_enc->channels = audio_channels;
3649
        audio_enc->sample_rate = audio_sample_rate;
3650
    } else {
3651
        audio_enc->codec_id = codec_id;
3652
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3653

    
3654
        if (audio_qscale > QSCALE_NONE) {
3655
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3656
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3657
        }
3658
        audio_enc->channels = audio_channels;
3659
        audio_enc->sample_fmt = audio_sample_fmt;
3660
        audio_enc->sample_rate = audio_sample_rate;
3661
        audio_enc->channel_layout = channel_layout;
3662
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3663
            audio_enc->channel_layout = 0;
3664
        choose_sample_fmt(st, codec);
3665
        choose_sample_rate(st, codec);
3666
    }
3667
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3668
    if (audio_language) {
3669
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3670
        av_freep(&audio_language);
3671
    }
3672

    
3673
    /* reset some key parameters */
3674
    audio_disable = 0;
3675
    av_freep(&audio_codec_name);
3676
    audio_stream_copy = 0;
3677
}
3678

    
3679
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3680
{
3681
    AVStream *st;
3682
    AVOutputStream *ost;
3683
    AVCodec *codec=NULL;
3684
    AVCodecContext *subtitle_enc;
3685
    enum CodecID codec_id = CODEC_ID_NONE;
3686

    
3687
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3688
    if (!st) {
3689
        fprintf(stderr, "Could not alloc stream\n");
3690
        ffmpeg_exit(1);
3691
    }
3692
    ost = new_output_stream(oc, file_idx);
3693
    subtitle_enc = st->codec;
3694
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3695
    if(!subtitle_stream_copy){
3696
        if (subtitle_codec_name) {
3697
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3698
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3699
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3700
        } else {
3701
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3702
            codec = avcodec_find_encoder(codec_id);
3703
        }
3704
    }
3705
    avcodec_get_context_defaults3(st->codec, codec);
3706

    
3707
    ost->bitstream_filters = subtitle_bitstream_filters;
3708
    subtitle_bitstream_filters= NULL;
3709

    
3710
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3711

    
3712
    if(subtitle_codec_tag)
3713
        subtitle_enc->codec_tag= subtitle_codec_tag;
3714

    
3715
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3716
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3717
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3718
    }
3719
    if (subtitle_stream_copy) {
3720
        st->stream_copy = 1;
3721
    } else {
3722
        subtitle_enc->codec_id = codec_id;
3723
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3724
    }
3725

    
3726
    if (subtitle_language) {
3727
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3728
        av_freep(&subtitle_language);
3729
    }
3730

    
3731
    subtitle_disable = 0;
3732
    av_freep(&subtitle_codec_name);
3733
    subtitle_stream_copy = 0;
3734
}
3735

    
3736
static int opt_new_stream(const char *opt, const char *arg)
3737
{
3738
    AVFormatContext *oc;
3739
    int file_idx = nb_output_files - 1;
3740
    if (nb_output_files <= 0) {
3741
        fprintf(stderr, "At least one output file must be specified\n");
3742
        ffmpeg_exit(1);
3743
    }
3744
    oc = output_files[file_idx];
3745

    
3746
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3747
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3748
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3749
    else av_assert0(0);
3750
    return 0;
3751
}
3752

    
3753
/* arg format is "output-stream-index:streamid-value". */
3754
static int opt_streamid(const char *opt, const char *arg)
3755
{
3756
    int idx;
3757
    char *p;
3758
    char idx_str[16];
3759

    
3760
    strncpy(idx_str, arg, sizeof(idx_str));
3761
    idx_str[sizeof(idx_str)-1] = '\0';
3762
    p = strchr(idx_str, ':');
3763
    if (!p) {
3764
        fprintf(stderr,
3765
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3766
                arg, opt);
3767
        ffmpeg_exit(1);
3768
    }
3769
    *p++ = '\0';
3770
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3771
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3772
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3773
    return 0;
3774
}
3775

    
3776
static void opt_output_file(const char *filename)
3777
{
3778
    AVFormatContext *oc;
3779
    int err, use_video, use_audio, use_subtitle;
3780
    int input_has_video, input_has_audio, input_has_subtitle;
3781
    AVFormatParameters params, *ap = &params;
3782
    AVOutputFormat *file_oformat;
3783

    
3784
    if (!strcmp(filename, "-"))
3785
        filename = "pipe:";
3786

    
3787
    oc = avformat_alloc_output_context(last_asked_format, NULL, filename);
3788
    last_asked_format = NULL;
3789
    if (!oc) {
3790
        print_error(filename, AVERROR(ENOMEM));
3791
        ffmpeg_exit(1);
3792
    }
3793
    file_oformat= oc->oformat;
3794

    
3795
    if (!strcmp(file_oformat->name, "ffm") &&
3796
        av_strstart(filename, "http:", NULL)) {
3797
        /* special case for files sent to ffserver: we get the stream
3798
           parameters from ffserver */
3799
        int err = read_ffserver_streams(oc, filename);
3800
        if (err < 0) {
3801
            print_error(filename, err);
3802
            ffmpeg_exit(1);
3803
        }
3804
    } else {
3805
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3806
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3807
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3808

    
3809
        /* disable if no corresponding type found and at least one
3810
           input file */
3811
        if (nb_input_files > 0) {
3812
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3813
                                         &input_has_subtitle);
3814
            if (!input_has_video)
3815
                use_video = 0;
3816
            if (!input_has_audio)
3817
                use_audio = 0;
3818
            if (!input_has_subtitle)
3819
                use_subtitle = 0;
3820
        }
3821

    
3822
        /* manual disable */
3823
        if (audio_disable)    use_audio    = 0;
3824
        if (video_disable)    use_video    = 0;
3825
        if (subtitle_disable) use_subtitle = 0;
3826

    
3827
        if (use_video)    new_video_stream(oc, nb_output_files);
3828
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3829
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3830

    
3831
        oc->timestamp = recording_timestamp;
3832

    
3833
        av_metadata_copy(&oc->metadata, metadata, 0);
3834
        av_metadata_free(&metadata);
3835
    }
3836

    
3837
    output_files[nb_output_files++] = oc;
3838

    
3839
    /* check filename in case of an image number is expected */
3840
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3841
        if (!av_filename_number_test(oc->filename)) {
3842
            print_error(oc->filename, AVERROR(EINVAL));
3843
            ffmpeg_exit(1);
3844
        }
3845
    }
3846

    
3847
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3848
        /* test if it already exists to avoid loosing precious files */
3849
        if (!file_overwrite &&
3850
            (strchr(filename, ':') == NULL ||
3851
             filename[1] == ':' ||
3852
             av_strstart(filename, "file:", NULL))) {
3853
            if (avio_check(filename, 0) == 0) {
3854
                if (!using_stdin) {
3855
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3856
                    fflush(stderr);
3857
                    if (!read_yesno()) {
3858
                        fprintf(stderr, "Not overwriting - exiting\n");
3859
                        ffmpeg_exit(1);
3860
                    }
3861
                }
3862
                else {
3863
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3864
                    ffmpeg_exit(1);
3865
                }
3866
            }
3867
        }
3868

    
3869
        /* open the file */
3870
        if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3871
            print_error(filename, err);
3872
            ffmpeg_exit(1);
3873
        }
3874
    }
3875

    
3876
    memset(ap, 0, sizeof(*ap));
3877
    if (av_set_parameters(oc, ap) < 0) {
3878
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3879
                oc->filename);
3880
        ffmpeg_exit(1);
3881
    }
3882

    
3883
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3884
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3885
    oc->loop_output = loop_output;
3886

    
3887
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3888

    
3889
    av_freep(&forced_key_frames);
3890
}
3891

    
3892
/* same option as mencoder */
3893
static int opt_pass(const char *opt, const char *arg)
3894
{
3895
    do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3896
    return 0;
3897
}
3898

    
3899
static int64_t getutime(void)
3900
{
3901
#if HAVE_GETRUSAGE
3902
    struct rusage rusage;
3903

    
3904
    getrusage(RUSAGE_SELF, &rusage);
3905
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3906
#elif HAVE_GETPROCESSTIMES
3907
    HANDLE proc;
3908
    FILETIME c, e, k, u;
3909
    proc = GetCurrentProcess();
3910
    GetProcessTimes(proc, &c, &e, &k, &u);
3911
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3912
#else
3913
    return av_gettime();
3914
#endif
3915
}
3916

    
3917
static int64_t getmaxrss(void)
3918
{
3919
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3920
    struct rusage rusage;
3921
    getrusage(RUSAGE_SELF, &rusage);
3922
    return (int64_t)rusage.ru_maxrss * 1024;
3923
#elif HAVE_GETPROCESSMEMORYINFO
3924
    HANDLE proc;
3925
    PROCESS_MEMORY_COUNTERS memcounters;
3926
    proc = GetCurrentProcess();
3927
    memcounters.cb = sizeof(memcounters);
3928
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3929
    return memcounters.PeakPagefileUsage;
3930
#else
3931
    return 0;
3932
#endif
3933
}
3934

    
3935
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3936
{
3937
    int i;
3938
    const char *p = str;
3939
    for(i = 0;; i++) {
3940
        dest[i] = atoi(p);
3941
        if(i == 63)
3942
            break;
3943
        p = strchr(p, ',');
3944
        if(!p) {
3945
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3946
            ffmpeg_exit(1);
3947
        }
3948
        p++;
3949
    }
3950
}
3951

    
3952
static void opt_inter_matrix(const char *arg)
3953
{
3954
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3955
    parse_matrix_coeffs(inter_matrix, arg);
3956
}
3957

    
3958
static void opt_intra_matrix(const char *arg)
3959
{
3960
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3961
    parse_matrix_coeffs(intra_matrix, arg);
3962
}
3963

    
3964
static void show_usage(void)
3965
{
3966
    printf("Hyper fast Audio and Video encoder\n");
3967
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3968
    printf("\n");
3969
}
3970

    
3971
static void show_help(void)
3972
{
3973
    AVCodec *c;
3974
    AVOutputFormat *oformat = NULL;
3975

    
3976
    av_log_set_callback(log_callback_help);
3977
    show_usage();
3978
    show_help_options(options, "Main options:\n",
3979
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3980
    show_help_options(options, "\nAdvanced options:\n",
3981
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3982
                      OPT_EXPERT);
3983
    show_help_options(options, "\nVideo options:\n",
3984
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3985
                      OPT_VIDEO);
3986
    show_help_options(options, "\nAdvanced Video options:\n",
3987
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3988
                      OPT_VIDEO | OPT_EXPERT);
3989
    show_help_options(options, "\nAudio options:\n",
3990
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3991
                      OPT_AUDIO);
3992
    show_help_options(options, "\nAdvanced Audio options:\n",
3993
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3994
                      OPT_AUDIO | OPT_EXPERT);
3995
    show_help_options(options, "\nSubtitle options:\n",
3996
                      OPT_SUBTITLE | OPT_GRAB,
3997
                      OPT_SUBTITLE);
3998
    show_help_options(options, "\nAudio/Video grab options:\n",
3999
                      OPT_GRAB,
4000
                      OPT_GRAB);
4001
    printf("\n");
4002
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4003
    printf("\n");
4004

    
4005
    /* individual codec options */
4006
    c = NULL;
4007
    while ((c = av_codec_next(c))) {
4008
        if (c->priv_class) {
4009
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4010
            printf("\n");
4011
        }
4012
    }
4013

    
4014
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4015
    printf("\n");
4016

    
4017
    /* individual muxer options */
4018
    while ((oformat = av_oformat_next(oformat))) {
4019
        if (oformat->priv_class) {
4020
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4021
            printf("\n");
4022
        }
4023
    }
4024

    
4025
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4026
}
4027

    
4028
static void opt_target(const char *arg)
4029
{
4030
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4031
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4032

    
4033
    if(!strncmp(arg, "pal-", 4)) {
4034
        norm = PAL;
4035
        arg += 4;
4036
    } else if(!strncmp(arg, "ntsc-", 5)) {
4037
        norm = NTSC;
4038
        arg += 5;
4039
    } else if(!strncmp(arg, "film-", 5)) {
4040
        norm = FILM;
4041
        arg += 5;
4042
    } else {
4043
        int fr;
4044
        /* Calculate FR via float to avoid int overflow */
4045
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4046
        if(fr == 25000) {
4047
            norm = PAL;
4048
        } else if((fr == 29970) || (fr == 23976)) {
4049
            norm = NTSC;
4050
        } else {
4051
            /* Try to determine PAL/NTSC by peeking in the input files */
4052
            if(nb_input_files) {
4053
                int i, j;
4054
                for(j = 0; j < nb_input_files; j++) {
4055
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
4056
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
4057
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4058
                            continue;
4059
                        fr = c->time_base.den * 1000 / c->time_base.num;
4060
                        if(fr == 25000) {
4061
                            norm = PAL;
4062
                            break;
4063
                        } else if((fr == 29970) || (fr == 23976)) {
4064
                            norm = NTSC;
4065
                            break;
4066
                        }
4067
                    }
4068
                    if(norm != UNKNOWN)
4069
                        break;
4070
                }
4071
            }
4072
        }
4073
        if(verbose > 0 && norm != UNKNOWN)
4074
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4075
    }
4076

    
4077
    if(norm == UNKNOWN) {
4078
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4079
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4080
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4081
        ffmpeg_exit(1);
4082
    }
4083

    
4084
    if(!strcmp(arg, "vcd")) {
4085

    
4086
        opt_video_codec("mpeg1video");
4087
        opt_audio_codec("mp2");
4088
        opt_format("vcd");
4089

    
4090
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4091
        opt_frame_rate(NULL, frame_rates[norm]);
4092
        opt_default("g", norm == PAL ? "15" : "18");
4093

    
4094
        opt_default("b", "1150000");
4095
        opt_default("maxrate", "1150000");
4096
        opt_default("minrate", "1150000");
4097
        opt_default("bufsize", "327680"); // 40*1024*8;
4098

    
4099
        opt_default("ab", "224000");
4100
        audio_sample_rate = 44100;
4101
        audio_channels = 2;
4102

    
4103
        opt_default("packetsize", "2324");
4104
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4105

    
4106
        /* We have to offset the PTS, so that it is consistent with the SCR.
4107
           SCR starts at 36000, but the first two packs contain only padding
4108
           and the first pack from the other stream, respectively, may also have
4109
           been written before.
4110
           So the real data starts at SCR 36000+3*1200. */
4111
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4112
    } else if(!strcmp(arg, "svcd")) {
4113

    
4114
        opt_video_codec("mpeg2video");
4115
        opt_audio_codec("mp2");
4116
        opt_format("svcd");
4117

    
4118
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4119
        opt_frame_rate(NULL, frame_rates[norm]);
4120
        opt_default("g", norm == PAL ? "15" : "18");
4121

    
4122
        opt_default("b", "2040000");
4123
        opt_default("maxrate", "2516000");
4124
        opt_default("minrate", "0"); //1145000;
4125
        opt_default("bufsize", "1835008"); //224*1024*8;
4126
        opt_default("flags", "+scan_offset");
4127

    
4128

    
4129
        opt_default("ab", "224000");
4130
        audio_sample_rate = 44100;
4131

    
4132
        opt_default("packetsize", "2324");
4133

    
4134
    } else if(!strcmp(arg, "dvd")) {
4135

    
4136
        opt_video_codec("mpeg2video");
4137
        opt_audio_codec("ac3");
4138
        opt_format("dvd");
4139

    
4140
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4141
        opt_frame_rate(NULL, frame_rates[norm]);
4142
        opt_default("g", norm == PAL ? "15" : "18");
4143

    
4144
        opt_default("b", "6000000");
4145
        opt_default("maxrate", "9000000");
4146
        opt_default("minrate", "0"); //1500000;
4147
        opt_default("bufsize", "1835008"); //224*1024*8;
4148

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

    
4152
        opt_default("ab", "448000");
4153
        audio_sample_rate = 48000;
4154

    
4155
    } else if(!strncmp(arg, "dv", 2)) {
4156

    
4157
        opt_format("dv");
4158

    
4159
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4160
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4161
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4162
        opt_frame_rate(NULL, frame_rates[norm]);
4163

    
4164
        audio_sample_rate = 48000;
4165
        audio_channels = 2;
4166

    
4167
    } else {
4168
        fprintf(stderr, "Unknown target: %s\n", arg);
4169
        ffmpeg_exit(1);
4170
    }
4171
}
4172

    
4173
static void opt_vstats_file (const char *arg)
4174
{
4175
    av_free (vstats_filename);
4176
    vstats_filename=av_strdup (arg);
4177
}
4178

    
4179
static void opt_vstats (void)
4180
{
4181
    char filename[40];
4182
    time_t today2 = time(NULL);
4183
    struct tm *today = localtime(&today2);
4184

    
4185
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4186
             today->tm_sec);
4187
    opt_vstats_file(filename);
4188
}
4189

    
4190
static int opt_bsf(const char *opt, const char *arg)
4191
{
4192
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4193
    AVBitStreamFilterContext **bsfp;
4194

    
4195
    if(!bsfc){
4196
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4197
        ffmpeg_exit(1);
4198
    }
4199

    
4200
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4201
          *opt == 'a' ? &audio_bitstream_filters :
4202
                        &subtitle_bitstream_filters;
4203
    while(*bsfp)
4204
        bsfp= &(*bsfp)->next;
4205

    
4206
    *bsfp= bsfc;
4207

    
4208
    return 0;
4209
}
4210

    
4211
static int opt_preset(const char *opt, const char *arg)
4212
{
4213
    FILE *f=NULL;
4214
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4215
    char *codec_name = *opt == 'v' ? video_codec_name :
4216
                       *opt == 'a' ? audio_codec_name :
4217
                                     subtitle_codec_name;
4218

    
4219
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4220
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4221
        ffmpeg_exit(1);
4222
    }
4223

    
4224
    while(!feof(f)){
4225
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4226
        if(line[0] == '#' && !e)
4227
            continue;
4228
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4229
        if(e){
4230
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4231
            ffmpeg_exit(1);
4232
        }
4233
        if(!strcmp(tmp, "acodec")){
4234
            opt_audio_codec(tmp2);
4235
        }else if(!strcmp(tmp, "vcodec")){
4236
            opt_video_codec(tmp2);
4237
        }else if(!strcmp(tmp, "scodec")){
4238
            opt_subtitle_codec(tmp2);
4239
        }else if(opt_default(tmp, tmp2) < 0){
4240
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4241
            ffmpeg_exit(1);
4242
        }
4243
    }
4244

    
4245
    fclose(f);
4246

    
4247
    return 0;
4248
}
4249

    
4250
static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4251
{
4252
}
4253

    
4254
static void opt_passlogfile(const char *arg)
4255
{
4256
    pass_logfilename_prefix = arg;
4257
    opt_default("passlogfile", arg);
4258
}
4259

    
4260
static const OptionDef options[] = {
4261
    /* main options */
4262
#include "cmdutils_common_opts.h"
4263
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4264
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4265
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4266
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4267
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4268
      "outfile[,metadata]:infile[,metadata]" },
4269
    { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4270
      "outfile[,metadata]:infile[,metadata]" },
4271
    { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4272
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4273
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4274
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4275
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4276
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4277
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4278
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4279
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4280
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4281
      "add timings for benchmarking" },
4282
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4283
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4284
      "dump each input packet" },
4285
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4286
      "when dumping packets, also dump the payload" },
4287
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4288
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4289
    { "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)", "" },
4290
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4291
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4292
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4293
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4294
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4295
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4296
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4297
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4298
    { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4299
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4300
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4301
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4302
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4303
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4304

    
4305
    /* video options */
4306
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4307
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4308
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4309
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4310
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4311
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4312
    { "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" },
4313
    { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4314
    { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4315
    { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4316
    { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4317
    { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4318
    { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4319
    { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4320
    { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4321
    { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4322
    { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4323
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4324
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4325
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4326
    { "qscale", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4327
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4328
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4329
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4330
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4331
      "use same quantizer as source (implies VBR)" },
4332
    { "pass", HAS_ARG | OPT_FUNC2 | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4333
    { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4334
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4335
      "deinterlace pictures" },
4336
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4337
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4338
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4339
#if CONFIG_AVFILTER
4340
    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4341
#endif
4342
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4343
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4344
    { "top", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4345
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4346
    { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4347
    { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4348
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4349
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4350
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4351
    { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4352
    { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4353

    
4354
    /* audio options */
4355
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4356
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4357
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4358
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4359
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4360
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4361
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4362
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4363
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4364
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4365
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4366
    { "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" },
4367

    
4368
    /* subtitle options */
4369
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4370
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4371
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4372
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4373
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4374

    
4375
    /* grab options */
4376
    { "vc", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4377
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4378
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4379

    
4380
    /* muxer options */
4381
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4382
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4383

    
4384
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4385
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4386
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4387

    
4388
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4389
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4390
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4391
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4392

    
4393
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4394
    { NULL, },
4395
};
4396

    
4397
int main(int argc, char **argv)
4398
{
4399
    int64_t ti;
4400

    
4401
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4402

    
4403
    if(argc>1 && !strcmp(argv[1], "-d")){
4404
        run_as_daemon=1;
4405
        verbose=-1;
4406
        av_log_set_callback(log_callback_null);
4407
        argc--;
4408
        argv++;
4409
    }
4410

    
4411
    avcodec_register_all();
4412
#if CONFIG_AVDEVICE
4413
    avdevice_register_all();
4414
#endif
4415
#if CONFIG_AVFILTER
4416
    avfilter_register_all();
4417
#endif
4418
    av_register_all();
4419

    
4420
#if HAVE_ISATTY
4421
    if(isatty(STDIN_FILENO))
4422
        avio_set_interrupt_cb(decode_interrupt_cb);
4423
#endif
4424

    
4425
    init_opts();
4426

    
4427
    show_banner();
4428

    
4429
    /* parse options */
4430
    parse_options(argc, argv, options, opt_output_file);
4431

    
4432
    if(nb_output_files <= 0 && nb_input_files == 0) {
4433
        show_usage();
4434
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4435
        ffmpeg_exit(1);
4436
    }
4437

    
4438
    /* file converter / grab */
4439
    if (nb_output_files <= 0) {
4440
        fprintf(stderr, "At least one output file must be specified\n");
4441
        ffmpeg_exit(1);
4442
    }
4443

    
4444
    if (nb_input_files == 0) {
4445
        fprintf(stderr, "At least one input file must be specified\n");
4446
        ffmpeg_exit(1);
4447
    }
4448

    
4449
    ti = getutime();
4450
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4451
                  stream_maps, nb_stream_maps) < 0)
4452
        ffmpeg_exit(1);
4453
    ti = getutime() - ti;
4454
    if (do_benchmark) {
4455
        int maxrss = getmaxrss() / 1024;
4456
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4457
    }
4458

    
4459
    return ffmpeg_exit(0);
4460
}