Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 39aafa5e

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 "libavcodec/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
#if !FF_API_MAX_STREAMS
117
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
118
#endif
119

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

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

    
134
static AVStreamMap *stream_maps = NULL;
135
static int nb_stream_maps;
136

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

    
144
static AVChapterMap *chapter_maps = NULL;
145
static int nb_chapter_maps;
146

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

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

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

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

    
198
static float mux_preload= 0.5;
199
static float mux_max_delay= 0.7;
200

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

    
228
static int rate_emu = 0;
229

    
230
static int  video_channel = 0;
231
static char *video_standard;
232

    
233
static int audio_volume = 256;
234

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

    
251
static float dts_delta_threshold = 10;
252

    
253
static int64_t timer_start;
254

    
255
static uint8_t *audio_buf;
256
static uint8_t *audio_out;
257
static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
258

    
259
static short *samples;
260

    
261
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
262
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
263
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
264

    
265
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
266

    
267
struct AVInputStream;
268

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

    
290
    float frame_aspect_ratio;
291

    
292
    /* full frame size of first frame */
293
    int original_height;
294
    int original_width;
295

    
296
    /* forced key frames */
297
    int64_t *forced_kf_pts;
298
    int forced_kf_count;
299
    int forced_kf_index;
300

    
301
    /* audio only */
302
    int audio_resample;
303
    ReSampleContext *resample; /* for audio resampling */
304
    int resample_sample_fmt;
305
    int resample_channels;
306
    int resample_sample_rate;
307
    int reformat_pair;
308
    AVAudioConvert *reformat_ctx;
309
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
310
    FILE *logfile;
311

    
312
#if CONFIG_AVFILTER
313
    AVFilterContext *output_video_filter;
314
    AVFilterContext *input_video_filter;
315
    AVFilterBufferRef *picref;
316
    char *avfilter;
317
    AVFilterGraph *graph;
318
#endif
319
} AVOutputStream;
320

    
321
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
322
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
323

    
324
typedef struct AVInputStream {
325
    int file_index;
326
    int index;
327
    AVStream *st;
328
    int discard;             /* true if stream data should be discarded */
329
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
330
    int64_t sample_index;      /* current sample */
331

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

    
345
typedef struct AVInputFile {
346
    int eof_reached;      /* true if eof reached */
347
    int ist_index;        /* index of first stream in ist_table */
348
    int buffer_size;      /* current total buffer size */
349
    int nb_streams;       /* nb streams we are aware of */
350
} AVInputFile;
351

    
352
#if HAVE_TERMIOS_H
353

    
354
/* init terminal so that we can grab keys */
355
static struct termios oldtty;
356
#endif
357

    
358
#if CONFIG_AVFILTER
359

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

    
371
    ost->graph = avfilter_graph_alloc();
372

    
373
    if (ist->st->sample_aspect_ratio.num){
374
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
375
    }else
376
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
377

    
378
    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
379
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
380
             sample_aspect_ratio.num, sample_aspect_ratio.den);
381

    
382
    ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
383
                                       "src", args, NULL, ost->graph);
384
    if (ret < 0)
385
        return ret;
386
    ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
387
                                       "out", NULL, &ffsink_ctx, ost->graph);
388
    if (ret < 0)
389
        return ret;
390
    last_filter = ost->input_video_filter;
391

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

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

    
408
    if (ost->avfilter) {
409
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
410
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
411

    
412
        outputs->name    = av_strdup("in");
413
        outputs->filter_ctx = last_filter;
414
        outputs->pad_idx = 0;
415
        outputs->next    = NULL;
416

    
417
        inputs->name    = av_strdup("out");
418
        inputs->filter_ctx = ost->output_video_filter;
419
        inputs->pad_idx = 0;
420
        inputs->next    = NULL;
421

    
422
        if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
423
            return ret;
424
        av_freep(&ost->avfilter);
425
    } else {
426
        if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
427
            return ret;
428
    }
429

    
430
    if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
431
        return ret;
432

    
433
    codec->width  = ost->output_video_filter->inputs[0]->w;
434
    codec->height = ost->output_video_filter->inputs[0]->h;
435
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
436
        ost->frame_aspect_ratio ? // overriden by the -aspect cli option
437
        av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
438
        ost->output_video_filter->inputs[0]->sample_aspect_ratio;
439

    
440
    return 0;
441
}
442
#endif /* CONFIG_AVFILTER */
443

    
444
static void term_exit(void)
445
{
446
    av_log(NULL, AV_LOG_QUIET, "");
447
#if HAVE_TERMIOS_H
448
    if(!daemon)
449
        tcsetattr (0, TCSANOW, &oldtty);
450
#endif
451
}
452

    
453
static volatile int received_sigterm = 0;
454

    
455
static void
456
sigterm_handler(int sig)
457
{
458
    received_sigterm = sig;
459
    q_pressed++;
460
    term_exit();
461
}
462

    
463
static void term_init(void)
464
{
465
#if HAVE_TERMIOS_H
466
    if(!daemon){
467
    struct termios tty;
468

    
469
    tcgetattr (0, &tty);
470
    oldtty = tty;
471
    atexit(term_exit);
472

    
473
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
474
                          |INLCR|IGNCR|ICRNL|IXON);
475
    tty.c_oflag |= OPOST;
476
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
477
    tty.c_cflag &= ~(CSIZE|PARENB);
478
    tty.c_cflag |= CS8;
479
    tty.c_cc[VMIN] = 1;
480
    tty.c_cc[VTIME] = 0;
481

    
482
    tcsetattr (0, TCSANOW, &tty);
483
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
484
    }
485
#endif
486

    
487
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
488
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
489
#ifdef SIGXCPU
490
    signal(SIGXCPU, sigterm_handler);
491
#endif
492
}
493

    
494
/* read a key without blocking */
495
static int read_key(void)
496
{
497
#if HAVE_TERMIOS_H
498
    int n = 1;
499
    unsigned char ch;
500
    struct timeval tv;
501
    fd_set rfds;
502

    
503
    if(daemon)
504
        return -1;
505

    
506
    FD_ZERO(&rfds);
507
    FD_SET(0, &rfds);
508
    tv.tv_sec = 0;
509
    tv.tv_usec = 0;
510
    n = select(1, &rfds, NULL, NULL, &tv);
511
    if (n > 0) {
512
        n = read(0, &ch, 1);
513
        if (n == 1)
514
            return ch;
515

    
516
        return n;
517
    }
518
#elif HAVE_KBHIT
519
    if(kbhit())
520
        return(getch());
521
#endif
522
    return -1;
523
}
524

    
525
static int decode_interrupt_cb(void)
526
{
527
    q_pressed += read_key() == 'q';
528
    return q_pressed > 1;
529
}
530

    
531
static int ffmpeg_exit(int ret)
532
{
533
    int i;
534

    
535
    /* close files */
536
    for(i=0;i<nb_output_files;i++) {
537
        AVFormatContext *s = output_files[i];
538
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
539
            avio_close(s->pb);
540
        avformat_free_context(s);
541
        av_free(output_streams_for_file[i]);
542
    }
543
    for(i=0;i<nb_input_files;i++) {
544
        av_close_input_file(input_files[i]);
545
        av_free(input_files_ts_scale[i]);
546
    }
547

    
548
    av_free(intra_matrix);
549
    av_free(inter_matrix);
550

    
551
    if (vstats_file)
552
        fclose(vstats_file);
553
    av_free(vstats_filename);
554

    
555
    av_free(streamid_map);
556
    av_free(input_codecs);
557
    av_free(output_codecs);
558
    av_free(stream_maps);
559
    av_free(meta_data_maps);
560

    
561
    av_free(video_codec_name);
562
    av_free(audio_codec_name);
563
    av_free(subtitle_codec_name);
564

    
565
    av_free(video_standard);
566

    
567
    uninit_opts();
568
    av_free(audio_buf);
569
    av_free(audio_out);
570
    allocated_audio_buf_size= allocated_audio_out_size= 0;
571
    av_free(samples);
572

    
573
#if CONFIG_AVFILTER
574
    avfilter_uninit();
575
#endif
576

    
577
    if (received_sigterm) {
578
        fprintf(stderr,
579
            "Received signal %d: terminating.\n",
580
            (int) received_sigterm);
581
        exit (255);
582
    }
583

    
584
    exit(ret); /* not all OS-es handle main() return value */
585
    return ret;
586
}
587

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

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

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

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

    
674
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
675
{
676
    int idx = oc->nb_streams - 1;
677
    AVOutputStream *ost;
678

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

    
695
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
696
{
697
    int i, err;
698
    AVFormatContext *ic;
699
    int nopts = 0;
700

    
701
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
702
    if (err < 0)
703
        return err;
704
    /* copy stream format */
705
    s->nb_streams = 0;
706
    for(i=0;i<ic->nb_streams;i++) {
707
        AVStream *st;
708
        AVCodec *codec;
709

    
710
        s->nb_streams++;
711

    
712
        // FIXME: a more elegant solution is needed
713
        st = av_mallocz(sizeof(AVStream));
714
        memcpy(st, ic->streams[i], sizeof(AVStream));
715
        st->codec = avcodec_alloc_context();
716
        if (!st->codec) {
717
            print_error(filename, AVERROR(ENOMEM));
718
            ffmpeg_exit(1);
719
        }
720
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
721
        s->streams[i] = st;
722

    
723
        codec = avcodec_find_encoder(st->codec->codec_id);
724
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
725
            if (audio_stream_copy) {
726
                st->stream_copy = 1;
727
            } else
728
                choose_sample_fmt(st, codec);
729
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
730
            if (video_stream_copy) {
731
                st->stream_copy = 1;
732
            } else
733
                choose_pixel_fmt(st, codec);
734
        }
735

    
736
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
737
            nopts = 1;
738

    
739
        new_output_stream(s, nb_output_files);
740
    }
741

    
742
    if (!nopts)
743
        s->timestamp = av_gettime();
744

    
745
    av_close_input_file(ic);
746
    return 0;
747
}
748

    
749
static double
750
get_sync_ipts(const AVOutputStream *ost)
751
{
752
    const AVInputStream *ist = ost->sync_ist;
753
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
754
}
755

    
756
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
757
    int ret;
758

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

    
778
        bsfc= bsfc->next;
779
    }
780

    
781
    ret= av_interleaved_write_frame(s, pkt);
782
    if(ret < 0){
783
        print_error("av_interleaved_write_frame()", ret);
784
        ffmpeg_exit(1);
785
    }
786
}
787

    
788
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
789

    
790
static void do_audio_out(AVFormatContext *s,
791
                         AVOutputStream *ost,
792
                         AVInputStream *ist,
793
                         unsigned char *buf, int size)
794
{
795
    uint8_t *buftmp;
796
    int64_t audio_out_size, audio_buf_size;
797
    int64_t allocated_for_size= size;
798

    
799
    int size_out, frame_bytes, ret, resample_changed;
800
    AVCodecContext *enc= ost->st->codec;
801
    AVCodecContext *dec= ist->st->codec;
802
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
803
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
804
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
805

    
806
need_realloc:
807
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
808
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
809
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
810
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
811
    audio_buf_size*= osize*enc->channels;
812

    
813
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
814
    if(coded_bps > 8*osize)
815
        audio_out_size= audio_out_size * coded_bps / (8*osize);
816
    audio_out_size += FF_MIN_BUFFER_SIZE;
817

    
818
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
819
        fprintf(stderr, "Buffer sizes too large\n");
820
        ffmpeg_exit(1);
821
    }
822

    
823
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
824
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
825
    if (!audio_buf || !audio_out){
826
        fprintf(stderr, "Out of memory in do_audio_out\n");
827
        ffmpeg_exit(1);
828
    }
829

    
830
    if (enc->channels != dec->channels)
831
        ost->audio_resample = 1;
832

    
833
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
834
                       ost->resample_channels    != dec->channels   ||
835
                       ost->resample_sample_rate != dec->sample_rate;
836

    
837
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
838
        if (resample_changed) {
839
            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",
840
                   ist->file_index, ist->index,
841
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
842
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
843
            ost->resample_sample_fmt  = dec->sample_fmt;
844
            ost->resample_channels    = dec->channels;
845
            ost->resample_sample_rate = dec->sample_rate;
846
            if (ost->resample)
847
                audio_resample_close(ost->resample);
848
        }
849
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
850
        if (audio_sync_method <= 1 &&
851
            ost->resample_sample_fmt  == enc->sample_fmt &&
852
            ost->resample_channels    == enc->channels   &&
853
            ost->resample_sample_rate == enc->sample_rate) {
854
            ost->resample = NULL;
855
            ost->audio_resample = 0;
856
        } else {
857
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
858
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
859
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
860
                                                   enc->sample_rate, dec->sample_rate,
861
                                                   enc->sample_fmt,  dec->sample_fmt,
862
                                                   16, 10, 0, 0.8);
863
            if (!ost->resample) {
864
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
865
                        dec->channels, dec->sample_rate,
866
                        enc->channels, enc->sample_rate);
867
                ffmpeg_exit(1);
868
            }
869
        }
870
    }
871

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

    
888
    if(audio_sync_method){
889
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
890
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
891
        double idelta= delta*dec->sample_rate / enc->sample_rate;
892
        int byte_delta= ((int)idelta)*2*dec->channels;
893

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

    
910
                    if(byte_delta > allocated_for_size - size){
911
                        allocated_for_size= byte_delta + (int64_t)size;
912
                        goto need_realloc;
913
                    }
914
                    ist->is_start=0;
915

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

    
936
    if (ost->audio_resample) {
937
        buftmp = audio_buf;
938
        size_out = audio_resample(ost->resample,
939
                                  (short *)buftmp, (short *)buf,
940
                                  size / (dec->channels * isize));
941
        size_out = size_out * enc->channels * osize;
942
    } else {
943
        buftmp = buf;
944
        size_out = size;
945
    }
946

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

    
963
    /* now encode as many frames as possible */
964
    if (enc->frame_size > 1) {
965
        /* output resampled raw samples */
966
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
967
            fprintf(stderr, "av_fifo_realloc2() failed\n");
968
            ffmpeg_exit(1);
969
        }
970
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
971

    
972
        frame_bytes = enc->frame_size * osize * enc->channels;
973

    
974
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
975
            AVPacket pkt;
976
            av_init_packet(&pkt);
977

    
978
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
979

    
980
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
981

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

    
997
            ost->sync_opts += enc->frame_size;
998
        }
999
    } else {
1000
        AVPacket pkt;
1001
        av_init_packet(&pkt);
1002

    
1003
        ost->sync_opts += size_out / (osize * enc->channels);
1004

    
1005
        /* output a pcm frame */
1006
        /* determine the size of the coded buffer */
1007
        size_out /= osize;
1008
        if (coded_bps)
1009
            size_out = size_out*coded_bps/8;
1010

    
1011
        if(size_out > audio_out_size){
1012
            fprintf(stderr, "Internal error, buffer size too small\n");
1013
            ffmpeg_exit(1);
1014
        }
1015

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

    
1034
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1035
{
1036
    AVCodecContext *dec;
1037
    AVPicture *picture2;
1038
    AVPicture picture_tmp;
1039
    uint8_t *buf = 0;
1040

    
1041
    dec = ist->st->codec;
1042

    
1043
    /* deinterlace : must be done before any resize */
1044
    if (do_deinterlace) {
1045
        int size;
1046

    
1047
        /* create temporary picture */
1048
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1049
        buf = av_malloc(size);
1050
        if (!buf)
1051
            return;
1052

    
1053
        picture2 = &picture_tmp;
1054
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1055

    
1056
        if(avpicture_deinterlace(picture2, picture,
1057
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1058
            /* if error, do not deinterlace */
1059
            fprintf(stderr, "Deinterlacing failed\n");
1060
            av_free(buf);
1061
            buf = NULL;
1062
            picture2 = picture;
1063
        }
1064
    } else {
1065
        picture2 = picture;
1066
    }
1067

    
1068
    if (picture != picture2)
1069
        *picture = *picture2;
1070
    *bufp = buf;
1071
}
1072

    
1073
/* we begin to correct av delay at this threshold */
1074
#define AV_DELAY_MAX 0.100
1075

    
1076
static void do_subtitle_out(AVFormatContext *s,
1077
                            AVOutputStream *ost,
1078
                            AVInputStream *ist,
1079
                            AVSubtitle *sub,
1080
                            int64_t pts)
1081
{
1082
    static uint8_t *subtitle_out = NULL;
1083
    int subtitle_out_max_size = 1024 * 1024;
1084
    int subtitle_out_size, nb, i;
1085
    AVCodecContext *enc;
1086
    AVPacket pkt;
1087

    
1088
    if (pts == AV_NOPTS_VALUE) {
1089
        fprintf(stderr, "Subtitle packets must have a pts\n");
1090
        if (exit_on_error)
1091
            ffmpeg_exit(1);
1092
        return;
1093
    }
1094

    
1095
    enc = ost->st->codec;
1096

    
1097
    if (!subtitle_out) {
1098
        subtitle_out = av_malloc(subtitle_out_max_size);
1099
    }
1100

    
1101
    /* Note: DVB subtitle need one packet to draw them and one other
1102
       packet to clear them */
1103
    /* XXX: signal it in the codec context ? */
1104
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1105
        nb = 2;
1106
    else
1107
        nb = 1;
1108

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

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

    
1139
static int bit_buffer_size= 1024*256;
1140
static uint8_t *bit_buffer= NULL;
1141

    
1142
static void do_video_out(AVFormatContext *s,
1143
                         AVOutputStream *ost,
1144
                         AVInputStream *ist,
1145
                         AVFrame *in_picture,
1146
                         int *frame_size)
1147
{
1148
    int nb_frames, i, ret;
1149
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1150
    AVCodecContext *enc, *dec;
1151
    double sync_ipts;
1152

    
1153
    enc = ost->st->codec;
1154
    dec = ist->st->codec;
1155

    
1156
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1157

    
1158
    /* by default, we output a single frame */
1159
    nb_frames = 1;
1160

    
1161
    *frame_size = 0;
1162

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

    
1188
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1189
    if (nb_frames <= 0)
1190
        return;
1191

    
1192
    formatted_picture = in_picture;
1193
    final_picture = formatted_picture;
1194
    padding_src = formatted_picture;
1195
    resampling_dst = &ost->pict_tmp;
1196

    
1197
    if (   ost->resample_height != ist->st->codec->height
1198
        || ost->resample_width  != ist->st->codec->width
1199
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1200

    
1201
        fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width,     ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1202
        if(!ost->video_resample)
1203
            ffmpeg_exit(1);
1204
    }
1205

    
1206
#if !CONFIG_AVFILTER
1207
    if (ost->video_resample) {
1208
        padding_src = NULL;
1209
        final_picture = &ost->pict_tmp;
1210
        if(  ost->resample_height != ist->st->codec->height
1211
          || ost->resample_width  != ist->st->codec->width
1212
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1213

    
1214
            /* initialize a new scaler context */
1215
            sws_freeContext(ost->img_resample_ctx);
1216
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1217
            ost->img_resample_ctx = sws_getContext(
1218
                ist->st->codec->width,
1219
                ist->st->codec->height,
1220
                ist->st->codec->pix_fmt,
1221
                ost->st->codec->width,
1222
                ost->st->codec->height,
1223
                ost->st->codec->pix_fmt,
1224
                sws_flags, NULL, NULL, NULL);
1225
            if (ost->img_resample_ctx == NULL) {
1226
                fprintf(stderr, "Cannot get resampling context\n");
1227
                ffmpeg_exit(1);
1228
            }
1229
        }
1230
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1231
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1232
    }
1233
#endif
1234

    
1235
    /* duplicates frame if needed */
1236
    for(i=0;i<nb_frames;i++) {
1237
        AVPacket pkt;
1238
        av_init_packet(&pkt);
1239
        pkt.stream_index= ost->index;
1240

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

    
1252
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1253
            enc->coded_frame = old_frame;
1254
        } else {
1255
            AVFrame big_picture;
1256

    
1257
            big_picture= *final_picture;
1258
            /* better than nothing: use input picture interlaced
1259
               settings */
1260
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1261
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1262
                if(top_field_first == -1)
1263
                    big_picture.top_field_first = in_picture->top_field_first;
1264
                else
1265
                    big_picture.top_field_first = top_field_first;
1266
            }
1267

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

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

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

    
1317
static double psnr(double d){
1318
    return -10.0*log(d)/log(10.0);
1319
}
1320

    
1321
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1322
                           int frame_size)
1323
{
1324
    AVCodecContext *enc;
1325
    int frame_number;
1326
    double ti1, bitrate, avg_bitrate;
1327

    
1328
    /* this is executed just the first time do_video_stats is called */
1329
    if (!vstats_file) {
1330
        vstats_file = fopen(vstats_filename, "w");
1331
        if (!vstats_file) {
1332
            perror("fopen");
1333
            ffmpeg_exit(1);
1334
        }
1335
    }
1336

    
1337
    enc = ost->st->codec;
1338
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1339
        frame_number = ost->frame_number;
1340
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1341
        if (enc->flags&CODEC_FLAG_PSNR)
1342
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1343

    
1344
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1345
        /* compute pts value */
1346
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1347
        if (ti1 < 0.01)
1348
            ti1 = 0.01;
1349

    
1350
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1351
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1352
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1353
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1354
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1355
    }
1356
}
1357

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

    
1372
    if (!is_last_report) {
1373
        int64_t cur_time;
1374
        /* display the report every 0.5 seconds */
1375
        cur_time = av_gettime();
1376
        if (last_time == -1) {
1377
            last_time = cur_time;
1378
            return;
1379
        }
1380
        if ((cur_time - last_time) < 500000)
1381
            return;
1382
        last_time = cur_time;
1383
    }
1384

    
1385

    
1386
    oc = output_files[0];
1387

    
1388
    total_size = avio_size(oc->pb);
1389
    if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1390
        total_size= avio_tell(oc->pb);
1391

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

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

    
1451
    if (verbose > 0 || is_last_report) {
1452
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1453

    
1454
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1455
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1456
            (double)total_size / 1024, ti1, bitrate);
1457

    
1458
        if (nb_frames_dup || nb_frames_drop)
1459
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1460
                  nb_frames_dup, nb_frames_drop);
1461

    
1462
        if (verbose >= 0)
1463
            fprintf(stderr, "%s    \r", buf);
1464

    
1465
        fflush(stderr);
1466
    }
1467

    
1468
    if (is_last_report && verbose >= 0){
1469
        int64_t raw= audio_size + video_size + extra_size;
1470
        fprintf(stderr, "\n");
1471
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1472
                video_size/1024.0,
1473
                audio_size/1024.0,
1474
                extra_size/1024.0,
1475
                100.0*(total_size - raw)/raw
1476
        );
1477
    }
1478
}
1479

    
1480
static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1481
{
1482
    int fill_char = 0x00;
1483
    if (sample_fmt == AV_SAMPLE_FMT_U8)
1484
        fill_char = 0x80;
1485
    memset(buf, fill_char, size);
1486
}
1487

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

    
1506
    AVPacket avpkt;
1507
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1508

    
1509
    if(ist->next_pts == AV_NOPTS_VALUE)
1510
        ist->next_pts= ist->pts;
1511

    
1512
    if (pkt == NULL) {
1513
        /* EOF handling */
1514
        av_init_packet(&avpkt);
1515
        avpkt.data = NULL;
1516
        avpkt.size = 0;
1517
        goto handle_eof;
1518
    } else {
1519
        avpkt = *pkt;
1520
    }
1521

    
1522
    if(pkt->dts != AV_NOPTS_VALUE)
1523
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1524
    if(pkt->pts != AV_NOPTS_VALUE)
1525
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1526

    
1527
    //while we have more to decode or while the decoder did output something on EOF
1528
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1529
        uint8_t *data_buf, *decoded_data_buf;
1530
        int data_size, decoded_data_size;
1531
    handle_eof:
1532
        ist->pts= ist->next_pts;
1533

    
1534
        if(avpkt.size && avpkt.size != pkt->size &&
1535
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1536
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1537
            ist->showed_multi_packet_warning=1;
1538
        }
1539

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

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

    
1633
        buffer_to_free = NULL;
1634
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1635
            pre_process_video_frame(ist, (AVPicture *)&picture,
1636
                                    &buffer_to_free);
1637
        }
1638

    
1639
#if CONFIG_AVFILTER
1640
        if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
1641
            for(i=0;i<nb_ostreams;i++) {
1642
                ost = ost_table[i];
1643
                if (ost->input_video_filter && ost->source_index == ist_index) {
1644
                    AVRational sar;
1645
                    if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1646
                    else                                  sar = ist->st->codec->sample_aspect_ratio;
1647
                    // add it to be filtered
1648
                    av_vsrc_buffer_add_frame2(ost->input_video_filter, &picture,
1649
                                             ist->pts,
1650
                                             sar, ist->st->codec->width, ist->st->codec->height,
1651
                                             ist->st->codec->pix_fmt, "0:0"); //TODO user setable params
1652
                }
1653
            }
1654
        }
1655
#endif
1656

    
1657
        // preprocess audio (volume)
1658
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1659
            if (audio_volume != 256) {
1660
                short *volp;
1661
                volp = samples;
1662
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1663
                    int v = ((*volp) * audio_volume + 128) >> 8;
1664
                    if (v < -32768) v = -32768;
1665
                    if (v >  32767) v = 32767;
1666
                    *volp++ = v;
1667
                }
1668
            }
1669
        }
1670

    
1671
        /* frame rate emulation */
1672
        if (rate_emu) {
1673
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1674
            int64_t now = av_gettime() - ist->start;
1675
            if (pts > now)
1676
                usleep(pts - now);
1677
        }
1678
        /* if output time reached then transcode raw format,
1679
           encode packets and output them */
1680
        if (start_time == 0 || ist->pts >= start_time)
1681
            for(i=0;i<nb_ostreams;i++) {
1682
                int frame_size;
1683

    
1684
                ost = ost_table[i];
1685
                if (ost->source_index == ist_index) {
1686
#if CONFIG_AVFILTER
1687
                frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1688
                    !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1689
                while (frame_available) {
1690
                    AVRational ist_pts_tb;
1691
                    if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1692
                        get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1693
                    if (ost->picref)
1694
                        ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1695
#endif
1696
                    os = output_files[ost->file_index];
1697

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

    
1701
                    if (ost->encoding_needed) {
1702
                        av_assert0(ist->decoding_needed);
1703
                        switch(ost->st->codec->codec_type) {
1704
                        case AVMEDIA_TYPE_AUDIO:
1705
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1706
                            break;
1707
                        case AVMEDIA_TYPE_VIDEO:
1708
#if CONFIG_AVFILTER
1709
                            if (ost->picref->video && !ost->frame_aspect_ratio)
1710
                                ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1711
#endif
1712
                            do_video_out(os, ost, ist, &picture, &frame_size);
1713
                            if (vstats_filename && frame_size)
1714
                                do_video_stats(os, ost, frame_size);
1715
                            break;
1716
                        case AVMEDIA_TYPE_SUBTITLE:
1717
                            do_subtitle_out(os, ost, ist, &subtitle,
1718
                                            pkt->pts);
1719
                            break;
1720
                        default:
1721
                            abort();
1722
                        }
1723
                    } else {
1724
                        AVFrame avframe; //FIXME/XXX remove this
1725
                        AVPacket opkt;
1726
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1727

    
1728
                        av_init_packet(&opkt);
1729

    
1730
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1731
#if !CONFIG_AVFILTER
1732
                            continue;
1733
#else
1734
                            goto cont;
1735
#endif
1736

    
1737
                        /* no reencoding needed : output the packet directly */
1738
                        /* force the input stream PTS */
1739

    
1740
                        avcodec_get_frame_defaults(&avframe);
1741
                        ost->st->codec->coded_frame= &avframe;
1742
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1743

    
1744
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1745
                            audio_size += data_size;
1746
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1747
                            video_size += data_size;
1748
                            ost->sync_opts++;
1749
                        }
1750

    
1751
                        opkt.stream_index= ost->index;
1752
                        if(pkt->pts != AV_NOPTS_VALUE)
1753
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1754
                        else
1755
                            opkt.pts= AV_NOPTS_VALUE;
1756

    
1757
                        if (pkt->dts == AV_NOPTS_VALUE)
1758
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1759
                        else
1760
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1761
                        opkt.dts -= ost_tb_start_time;
1762

    
1763
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1764
                        opkt.flags= pkt->flags;
1765

    
1766
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1767
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1768
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1769
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1770
                           ) {
1771
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1772
                                opkt.destruct= av_destruct_packet;
1773
                        } else {
1774
                            opkt.data = data_buf;
1775
                            opkt.size = data_size;
1776
                        }
1777

    
1778
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1779
                        ost->st->codec->frame_number++;
1780
                        ost->frame_number++;
1781
                        av_free_packet(&opkt);
1782
                    }
1783
#if CONFIG_AVFILTER
1784
                    cont:
1785
                    frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1786
                                       ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1787
                    if(ost->picref)
1788
                        avfilter_unref_buffer(ost->picref);
1789
                }
1790
#endif
1791
                }
1792
            }
1793

    
1794
        av_free(buffer_to_free);
1795
        /* XXX: allocate the subtitles in the codec ? */
1796
        if (subtitle_to_free) {
1797
            avsubtitle_free(subtitle_to_free);
1798
            subtitle_to_free = NULL;
1799
        }
1800
    }
1801
 discard_packet:
1802
    if (pkt == NULL) {
1803
        /* EOF handling */
1804

    
1805
        for(i=0;i<nb_ostreams;i++) {
1806
            ost = ost_table[i];
1807
            if (ost->source_index == ist_index) {
1808
                AVCodecContext *enc= ost->st->codec;
1809
                os = output_files[ost->file_index];
1810

    
1811
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1812
                    continue;
1813
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1814
                    continue;
1815

    
1816
                if (ost->encoding_needed) {
1817
                    for(;;) {
1818
                        AVPacket pkt;
1819
                        int fifo_bytes;
1820
                        av_init_packet(&pkt);
1821
                        pkt.stream_index= ost->index;
1822

    
1823
                        switch(ost->st->codec->codec_type) {
1824
                        case AVMEDIA_TYPE_AUDIO:
1825
                            fifo_bytes = av_fifo_size(ost->fifo);
1826
                            ret = 0;
1827
                            /* encode any samples remaining in fifo */
1828
                            if (fifo_bytes > 0) {
1829
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1830
                                int fs_tmp = enc->frame_size;
1831

    
1832
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1833
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1834
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1835
                                } else { /* pad */
1836
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1837
                                    if (allocated_audio_buf_size < frame_bytes)
1838
                                        ffmpeg_exit(1);
1839
                                    generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1840
                                }
1841

    
1842
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1843
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1844
                                                          ost->st->time_base.num, enc->sample_rate);
1845
                                enc->frame_size = fs_tmp;
1846
                            }
1847
                            if(ret <= 0) {
1848
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1849
                            }
1850
                            if (ret < 0) {
1851
                                fprintf(stderr, "Audio encoding failed\n");
1852
                                ffmpeg_exit(1);
1853
                            }
1854
                            audio_size += ret;
1855
                            pkt.flags |= AV_PKT_FLAG_KEY;
1856
                            break;
1857
                        case AVMEDIA_TYPE_VIDEO:
1858
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1859
                            if (ret < 0) {
1860
                                fprintf(stderr, "Video encoding failed\n");
1861
                                ffmpeg_exit(1);
1862
                            }
1863
                            video_size += ret;
1864
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1865
                                pkt.flags |= AV_PKT_FLAG_KEY;
1866
                            if (ost->logfile && enc->stats_out) {
1867
                                fprintf(ost->logfile, "%s", enc->stats_out);
1868
                            }
1869
                            break;
1870
                        default:
1871
                            ret=-1;
1872
                        }
1873

    
1874
                        if(ret<=0)
1875
                            break;
1876
                        pkt.data= bit_buffer;
1877
                        pkt.size= ret;
1878
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1879
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1880
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1881
                    }
1882
                }
1883
            }
1884
        }
1885
    }
1886

    
1887
    return 0;
1888
 fail_decode:
1889
    return -1;
1890
}
1891

    
1892
static void print_sdp(AVFormatContext **avc, int n)
1893
{
1894
    char sdp[2048];
1895

    
1896
    av_sdp_create(avc, n, sdp, sizeof(sdp));
1897
    printf("SDP:\n%s\n", sdp);
1898
    fflush(stdout);
1899
}
1900

    
1901
static int copy_chapters(int infile, int outfile)
1902
{
1903
    AVFormatContext *is = input_files[infile];
1904
    AVFormatContext *os = output_files[outfile];
1905
    int i;
1906

    
1907
    for (i = 0; i < is->nb_chapters; i++) {
1908
        AVChapter *in_ch = is->chapters[i], *out_ch;
1909
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1910
                                      AV_TIME_BASE_Q, in_ch->time_base);
1911
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1912
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1913

    
1914

    
1915
        if (in_ch->end < ts_off)
1916
            continue;
1917
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1918
            break;
1919

    
1920
        out_ch = av_mallocz(sizeof(AVChapter));
1921
        if (!out_ch)
1922
            return AVERROR(ENOMEM);
1923

    
1924
        out_ch->id        = in_ch->id;
1925
        out_ch->time_base = in_ch->time_base;
1926
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1927
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1928

    
1929
        if (metadata_chapters_autocopy)
1930
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1931

    
1932
        os->nb_chapters++;
1933
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1934
        if (!os->chapters)
1935
            return AVERROR(ENOMEM);
1936
        os->chapters[os->nb_chapters - 1] = out_ch;
1937
    }
1938
    return 0;
1939
}
1940

    
1941
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1942
                                    AVCodecContext *avctx)
1943
{
1944
    char *p;
1945
    int n = 1, i;
1946
    int64_t t;
1947

    
1948
    for (p = kf; *p; p++)
1949
        if (*p == ',')
1950
            n++;
1951
    ost->forced_kf_count = n;
1952
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1953
    if (!ost->forced_kf_pts) {
1954
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1955
        ffmpeg_exit(1);
1956
    }
1957
    for (i = 0; i < n; i++) {
1958
        p = i ? strchr(p, ',') + 1 : kf;
1959
        t = parse_time_or_die("force_key_frames", p, 1);
1960
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1961
    }
1962
}
1963

    
1964
/*
1965
 * The following code is the main loop of the file converter
1966
 */
1967
static int transcode(AVFormatContext **output_files,
1968
                     int nb_output_files,
1969
                     AVFormatContext **input_files,
1970
                     int nb_input_files,
1971
                     AVStreamMap *stream_maps, int nb_stream_maps)
1972
{
1973
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0, step;
1974
    AVFormatContext *is, *os;
1975
    AVCodecContext *codec, *icodec;
1976
    AVOutputStream *ost, **ost_table = NULL;
1977
    AVInputStream *ist, **ist_table = NULL;
1978
    AVInputFile *file_table;
1979
    char error[1024];
1980
    int key;
1981
    int want_sdp = 1;
1982
    uint8_t no_packet[MAX_FILES]={0};
1983
    int no_packet_count=0;
1984
    int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
1985
    int nb_streams[AVMEDIA_TYPE_NB]={0};
1986

    
1987
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1988
    if (!file_table)
1989
        goto fail;
1990

    
1991
    /* input stream init */
1992
    j = 0;
1993
    for(i=0;i<nb_input_files;i++) {
1994
        is = input_files[i];
1995
        file_table[i].ist_index = j;
1996
        file_table[i].nb_streams = is->nb_streams;
1997
        j += is->nb_streams;
1998
    }
1999
    nb_istreams = j;
2000

    
2001
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
2002
    if (!ist_table)
2003
        goto fail;
2004

    
2005
    for(i=0;i<nb_istreams;i++) {
2006
        ist = av_mallocz(sizeof(AVInputStream));
2007
        if (!ist)
2008
            goto fail;
2009
        ist_table[i] = ist;
2010
    }
2011
    j = 0;
2012
    for(i=0;i<nb_input_files;i++) {
2013
        is = input_files[i];
2014
        for(k=0;k<is->nb_streams;k++) {
2015
            ist = ist_table[j++];
2016
            ist->st = is->streams[k];
2017
            ist->file_index = i;
2018
            ist->index = k;
2019
            ist->discard = 1; /* the stream is discarded by default
2020
                                 (changed later) */
2021

    
2022
            if (rate_emu) {
2023
                ist->start = av_gettime();
2024
            }
2025
        }
2026
    }
2027

    
2028
    /* output stream init */
2029
    nb_ostreams = 0;
2030
    for(i=0;i<nb_output_files;i++) {
2031
        os = output_files[i];
2032
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2033
            av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2034
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2035
            ret = AVERROR(EINVAL);
2036
            goto fail;
2037
        }
2038
        nb_ostreams += os->nb_streams;
2039
    }
2040
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2041
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
2042
        ret = AVERROR(EINVAL);
2043
        goto fail;
2044
    }
2045

    
2046
    /* Sanity check the mapping args -- do the input files & streams exist? */
2047
    for(i=0;i<nb_stream_maps;i++) {
2048
        int fi = stream_maps[i].file_index;
2049
        int si = stream_maps[i].stream_index;
2050

    
2051
        if (fi < 0 || fi > nb_input_files - 1 ||
2052
            si < 0 || si > file_table[fi].nb_streams - 1) {
2053
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2054
            ret = AVERROR(EINVAL);
2055
            goto fail;
2056
        }
2057
        fi = stream_maps[i].sync_file_index;
2058
        si = stream_maps[i].sync_stream_index;
2059
        if (fi < 0 || fi > nb_input_files - 1 ||
2060
            si < 0 || si > file_table[fi].nb_streams - 1) {
2061
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2062
            ret = AVERROR(EINVAL);
2063
            goto fail;
2064
        }
2065
    }
2066

    
2067
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2068
    if (!ost_table)
2069
        goto fail;
2070

    
2071
    for(k=0;k<nb_output_files;k++) {
2072
        os = output_files[k];
2073
        for(i=0;i<os->nb_streams;i++,n++) {
2074
            nb_streams[os->streams[i]->codec->codec_type]++;
2075
        }
2076
    }
2077
    for(step=1<<30; step; step>>=1){
2078
        int found_streams[AVMEDIA_TYPE_NB]={0};
2079
        for(j=0; j<AVMEDIA_TYPE_NB; j++)
2080
            nb_frame_threshold[j] += step;
2081

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

    
2118
                /* Sanity check that the stream types match */
2119
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2120
                    int i= ost->file_index;
2121
                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2122
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2123
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2124
                        ost->file_index, ost->index);
2125
                    ffmpeg_exit(1);
2126
                }
2127

    
2128
            } else {
2129
                /* get corresponding input stream index : we select the first one with the right type */
2130
                found = 0;
2131
                for(j=0;j<nb_istreams;j++) {
2132
                    int skip=0;
2133
                    ist = ist_table[j];
2134
                    if(opt_programid){
2135
                        int pi,si;
2136
                        AVFormatContext *f= input_files[ ist->file_index ];
2137
                        skip=1;
2138
                        for(pi=0; pi<f->nb_programs; pi++){
2139
                            AVProgram *p= f->programs[pi];
2140
                            if(p->id == opt_programid)
2141
                                for(si=0; si<p->nb_stream_indexes; si++){
2142
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2143
                                        skip=0;
2144
                                }
2145
                        }
2146
                    }
2147
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2148
                        ist->st->codec->codec_type == ost->st->codec->codec_type &&
2149
                        nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2150
                            ost->source_index = j;
2151
                            found = 1;
2152
                            break;
2153
                    }
2154
                }
2155

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

    
2185
    /* for each output stream, we compute the right encoding parameters */
2186
    for(i=0;i<nb_ostreams;i++) {
2187
        ost = ost_table[i];
2188
        os = output_files[ost->file_index];
2189
        ist = ist_table[ost->source_index];
2190

    
2191
        codec = ost->st->codec;
2192
        icodec = ist->st->codec;
2193

    
2194
        if (metadata_streams_autocopy)
2195
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2196
                             AV_METADATA_DONT_OVERWRITE);
2197

    
2198
        ost->st->disposition = ist->st->disposition;
2199
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2200
        codec->chroma_sample_location = icodec->chroma_sample_location;
2201

    
2202
        if (ost->st->stream_copy) {
2203
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2204

    
2205
            if (extra_size > INT_MAX)
2206
                goto fail;
2207

    
2208
            /* if stream_copy is selected, no need to decode or encode */
2209
            codec->codec_id = icodec->codec_id;
2210
            codec->codec_type = icodec->codec_type;
2211

    
2212
            if(!codec->codec_tag){
2213
                if(   !os->oformat->codec_tag
2214
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2215
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2216
                    codec->codec_tag = icodec->codec_tag;
2217
            }
2218

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

    
2316
                    ost->original_height = icodec->height;
2317
                    ost->original_width  = icodec->width;
2318
#endif
2319
                    codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2320
                }
2321
                ost->resample_height = icodec->height;
2322
                ost->resample_width  = icodec->width;
2323
                ost->resample_pix_fmt= icodec->pix_fmt;
2324
                ost->encoding_needed = 1;
2325
                ist->decoding_needed = 1;
2326

    
2327
#if CONFIG_AVFILTER
2328
                if (configure_video_filters(ist, ost)) {
2329
                    fprintf(stderr, "Error opening filters!\n");
2330
                    exit(1);
2331
                }
2332
#endif
2333
                break;
2334
            case AVMEDIA_TYPE_SUBTITLE:
2335
                ost->encoding_needed = 1;
2336
                ist->decoding_needed = 1;
2337
                break;
2338
            default:
2339
                abort();
2340
                break;
2341
            }
2342
            /* two pass mode */
2343
            if (ost->encoding_needed &&
2344
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2345
                char logfilename[1024];
2346
                FILE *f;
2347

    
2348
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2349
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2350
                         i);
2351
                if (codec->flags & CODEC_FLAG_PASS1) {
2352
                    f = fopen(logfilename, "wb");
2353
                    if (!f) {
2354
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2355
                        ffmpeg_exit(1);
2356
                    }
2357
                    ost->logfile = f;
2358
                } else {
2359
                    char  *logbuffer;
2360
                    size_t logbuffer_size;
2361
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2362
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2363
                        ffmpeg_exit(1);
2364
                    }
2365
                    codec->stats_in = logbuffer;
2366
                }
2367
            }
2368
        }
2369
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2370
            /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2371
            int size= codec->width * codec->height;
2372
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2373
        }
2374
    }
2375

    
2376
    if (!bit_buffer)
2377
        bit_buffer = av_malloc(bit_buffer_size);
2378
    if (!bit_buffer) {
2379
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2380
                bit_buffer_size);
2381
        ret = AVERROR(ENOMEM);
2382
        goto fail;
2383
    }
2384

    
2385
    /* open each encoder */
2386
    for(i=0;i<nb_ostreams;i++) {
2387
        ost = ost_table[i];
2388
        if (ost->encoding_needed) {
2389
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2390
            AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2391
            if (!codec)
2392
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2393
            if (!codec) {
2394
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2395
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2396
                ret = AVERROR(EINVAL);
2397
                goto dump_format;
2398
            }
2399
            if (dec->subtitle_header) {
2400
                ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2401
                if (!ost->st->codec->subtitle_header) {
2402
                    ret = AVERROR(ENOMEM);
2403
                    goto dump_format;
2404
                }
2405
                memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2406
                ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2407
            }
2408
            if (avcodec_open(ost->st->codec, codec) < 0) {
2409
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2410
                        ost->file_index, ost->index);
2411
                ret = AVERROR(EINVAL);
2412
                goto dump_format;
2413
            }
2414
            extra_size += ost->st->codec->extradata_size;
2415
        }
2416
    }
2417

    
2418
    /* open each decoder */
2419
    for(i=0;i<nb_istreams;i++) {
2420
        ist = ist_table[i];
2421
        if (ist->decoding_needed) {
2422
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2423
            if (!codec)
2424
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2425
            if (!codec) {
2426
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2427
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2428
                ret = AVERROR(EINVAL);
2429
                goto dump_format;
2430
            }
2431
            if (avcodec_open(ist->st->codec, codec) < 0) {
2432
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2433
                        ist->file_index, ist->index);
2434
                ret = AVERROR(EINVAL);
2435
                goto dump_format;
2436
            }
2437
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2438
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2439
        }
2440
    }
2441

    
2442
    /* init pts */
2443
    for(i=0;i<nb_istreams;i++) {
2444
        AVStream *st;
2445
        ist = ist_table[i];
2446
        st= ist->st;
2447
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2448
        ist->next_pts = AV_NOPTS_VALUE;
2449
        ist->is_start = 1;
2450
    }
2451

    
2452
    /* set meta data information from input file if required */
2453
    for (i=0;i<nb_meta_data_maps;i++) {
2454
        AVFormatContext *files[2];
2455
        AVMetadata      **meta[2];
2456
        int j;
2457

    
2458
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2459
        if ((index) < 0 || (index) >= (nb_elems)) {\
2460
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2461
                     (desc), (index));\
2462
            ret = AVERROR(EINVAL);\
2463
            goto dump_format;\
2464
        }
2465

    
2466
        int out_file_index = meta_data_maps[i][0].file;
2467
        int in_file_index = meta_data_maps[i][1].file;
2468
        if (in_file_index < 0 || out_file_index < 0)
2469
            continue;
2470
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2471
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2472

    
2473
        files[0] = output_files[out_file_index];
2474
        files[1] = input_files[in_file_index];
2475

    
2476
        for (j = 0; j < 2; j++) {
2477
            AVMetaDataMap *map = &meta_data_maps[i][j];
2478

    
2479
            switch (map->type) {
2480
            case 'g':
2481
                meta[j] = &files[j]->metadata;
2482
                break;
2483
            case 's':
2484
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2485
                meta[j] = &files[j]->streams[map->index]->metadata;
2486
                break;
2487
            case 'c':
2488
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2489
                meta[j] = &files[j]->chapters[map->index]->metadata;
2490
                break;
2491
            case 'p':
2492
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2493
                meta[j] = &files[j]->programs[map->index]->metadata;
2494
                break;
2495
            }
2496
        }
2497

    
2498
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2499
    }
2500

    
2501
    /* copy global metadata by default */
2502
    if (metadata_global_autocopy) {
2503

    
2504
        for (i = 0; i < nb_output_files; i++)
2505
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2506
                             AV_METADATA_DONT_OVERWRITE);
2507
    }
2508

    
2509
    /* copy chapters according to chapter maps */
2510
    for (i = 0; i < nb_chapter_maps; i++) {
2511
        int infile  = chapter_maps[i].in_file;
2512
        int outfile = chapter_maps[i].out_file;
2513

    
2514
        if (infile < 0 || outfile < 0)
2515
            continue;
2516
        if (infile >= nb_input_files) {
2517
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2518
            ret = AVERROR(EINVAL);
2519
            goto dump_format;
2520
        }
2521
        if (outfile >= nb_output_files) {
2522
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2523
            ret = AVERROR(EINVAL);
2524
            goto dump_format;
2525
        }
2526
        copy_chapters(infile, outfile);
2527
    }
2528

    
2529
    /* copy chapters from the first input file that has them*/
2530
    if (!nb_chapter_maps)
2531
        for (i = 0; i < nb_input_files; i++) {
2532
            if (!input_files[i]->nb_chapters)
2533
                continue;
2534

    
2535
            for (j = 0; j < nb_output_files; j++)
2536
                if ((ret = copy_chapters(i, j)) < 0)
2537
                    goto dump_format;
2538
            break;
2539
        }
2540

    
2541
    /* open files and write file headers */
2542
    for(i=0;i<nb_output_files;i++) {
2543
        os = output_files[i];
2544
        if (av_write_header(os) < 0) {
2545
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2546
            ret = AVERROR(EINVAL);
2547
            goto dump_format;
2548
        }
2549
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2550
            want_sdp = 0;
2551
        }
2552
    }
2553

    
2554
 dump_format:
2555
    /* dump the file output parameters - cannot be done before in case
2556
       of stream copy */
2557
    for(i=0;i<nb_output_files;i++) {
2558
        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2559
    }
2560

    
2561
    /* dump the stream mapping */
2562
    if (verbose >= 0) {
2563
        fprintf(stderr, "Stream mapping:\n");
2564
        for(i=0;i<nb_ostreams;i++) {
2565
            ost = ost_table[i];
2566
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2567
                    ist_table[ost->source_index]->file_index,
2568
                    ist_table[ost->source_index]->index,
2569
                    ost->file_index,
2570
                    ost->index);
2571
            if (ost->sync_ist != ist_table[ost->source_index])
2572
                fprintf(stderr, " [sync #%d.%d]",
2573
                        ost->sync_ist->file_index,
2574
                        ost->sync_ist->index);
2575
            fprintf(stderr, "\n");
2576
        }
2577
    }
2578

    
2579
    if (ret) {
2580
        fprintf(stderr, "%s\n", error);
2581
        goto fail;
2582
    }
2583

    
2584
    if (want_sdp) {
2585
        print_sdp(output_files, nb_output_files);
2586
    }
2587

    
2588
    if (!using_stdin) {
2589
        if(verbose >= 0)
2590
            fprintf(stderr, "Press [q] to stop encoding\n");
2591
        avio_set_interrupt_cb(decode_interrupt_cb);
2592
    }
2593
    term_init();
2594

    
2595
    timer_start = av_gettime();
2596

    
2597
    for(; received_sigterm == 0;) {
2598
        int file_index, ist_index;
2599
        AVPacket pkt;
2600
        double ipts_min;
2601
        double opts_min;
2602

    
2603
    redo:
2604
        ipts_min= 1e100;
2605
        opts_min= 1e100;
2606
        /* if 'q' pressed, exits */
2607
        if (!using_stdin) {
2608
            if (q_pressed)
2609
                break;
2610
            /* read_key() returns 0 on EOF */
2611
            key = read_key();
2612
            if (key == 'q')
2613
                break;
2614
        }
2615

    
2616
        /* select the stream that we must read now by looking at the
2617
           smallest output pts */
2618
        file_index = -1;
2619
        for(i=0;i<nb_ostreams;i++) {
2620
            double ipts, opts;
2621
            ost = ost_table[i];
2622
            os = output_files[ost->file_index];
2623
            ist = ist_table[ost->source_index];
2624
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2625
                continue;
2626
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2627
            ipts = (double)ist->pts;
2628
            if (!file_table[ist->file_index].eof_reached){
2629
                if(ipts < ipts_min) {
2630
                    ipts_min = ipts;
2631
                    if(input_sync ) file_index = ist->file_index;
2632
                }
2633
                if(opts < opts_min) {
2634
                    opts_min = opts;
2635
                    if(!input_sync) file_index = ist->file_index;
2636
                }
2637
            }
2638
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2639
                file_index= -1;
2640
                break;
2641
            }
2642
        }
2643
        /* if none, if is finished */
2644
        if (file_index < 0) {
2645
            if(no_packet_count){
2646
                no_packet_count=0;
2647
                memset(no_packet, 0, sizeof(no_packet));
2648
                usleep(10000);
2649
                continue;
2650
            }
2651
            break;
2652
        }
2653

    
2654
        /* finish if limit size exhausted */
2655
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2656
            break;
2657

    
2658
        /* read a frame from it and output it in the fifo */
2659
        is = input_files[file_index];
2660
        ret= av_read_frame(is, &pkt);
2661
        if(ret == AVERROR(EAGAIN)){
2662
            no_packet[file_index]=1;
2663
            no_packet_count++;
2664
            continue;
2665
        }
2666
        if (ret < 0) {
2667
            file_table[file_index].eof_reached = 1;
2668
            if (opt_shortest)
2669
                break;
2670
            else
2671
                continue;
2672
        }
2673

    
2674
        no_packet_count=0;
2675
        memset(no_packet, 0, sizeof(no_packet));
2676

    
2677
        if (do_pkt_dump) {
2678
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2679
                             is->streams[pkt.stream_index]);
2680
        }
2681
        /* the following test is needed in case new streams appear
2682
           dynamically in stream : we ignore them */
2683
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2684
            goto discard_packet;
2685
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2686
        ist = ist_table[ist_index];
2687
        if (ist->discard)
2688
            goto discard_packet;
2689

    
2690
        if (pkt.dts != AV_NOPTS_VALUE)
2691
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2692
        if (pkt.pts != AV_NOPTS_VALUE)
2693
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2694

    
2695
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2696
            && input_files_ts_scale[file_index][pkt.stream_index]){
2697
            if(pkt.pts != AV_NOPTS_VALUE)
2698
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2699
            if(pkt.dts != AV_NOPTS_VALUE)
2700
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2701
        }
2702

    
2703
//        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);
2704
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2705
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2706
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2707
            int64_t delta= pkt_dts - ist->next_pts;
2708
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2709
                input_files_ts_offset[ist->file_index]-= delta;
2710
                if (verbose > 2)
2711
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2712
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2713
                if(pkt.pts != AV_NOPTS_VALUE)
2714
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2715
            }
2716
        }
2717

    
2718
        /* finish if recording time exhausted */
2719
        if (recording_time != INT64_MAX &&
2720
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2721
            ist->is_past_recording_time = 1;
2722
            goto discard_packet;
2723
        }
2724

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

    
2728
            if (verbose >= 0)
2729
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2730
                        ist->file_index, ist->index);
2731
            if (exit_on_error)
2732
                ffmpeg_exit(1);
2733
            av_free_packet(&pkt);
2734
            goto redo;
2735
        }
2736

    
2737
    discard_packet:
2738
        av_free_packet(&pkt);
2739

    
2740
        /* dump report by using the output first video and audio streams */
2741
        print_report(output_files, ost_table, nb_ostreams, 0);
2742
    }
2743

    
2744
    /* at the end of stream, we must flush the decoder buffers */
2745
    for(i=0;i<nb_istreams;i++) {
2746
        ist = ist_table[i];
2747
        if (ist->decoding_needed) {
2748
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2749
        }
2750
    }
2751

    
2752
    term_exit();
2753

    
2754
    /* write the trailer if needed and close file */
2755
    for(i=0;i<nb_output_files;i++) {
2756
        os = output_files[i];
2757
        av_write_trailer(os);
2758
    }
2759

    
2760
    /* dump report by using the first video and audio streams */
2761
    print_report(output_files, ost_table, nb_ostreams, 1);
2762

    
2763
    /* close each encoder */
2764
    for(i=0;i<nb_ostreams;i++) {
2765
        ost = ost_table[i];
2766
        if (ost->encoding_needed) {
2767
            av_freep(&ost->st->codec->stats_in);
2768
            avcodec_close(ost->st->codec);
2769
        }
2770
#if CONFIG_AVFILTER
2771
        avfilter_graph_free(&ost->graph);
2772
#endif
2773
    }
2774

    
2775
    /* close each decoder */
2776
    for(i=0;i<nb_istreams;i++) {
2777
        ist = ist_table[i];
2778
        if (ist->decoding_needed) {
2779
            avcodec_close(ist->st->codec);
2780
        }
2781
    }
2782

    
2783
    /* finished ! */
2784
    ret = 0;
2785

    
2786
 fail:
2787
    av_freep(&bit_buffer);
2788
    av_free(file_table);
2789

    
2790
    if (ist_table) {
2791
        for(i=0;i<nb_istreams;i++) {
2792
            ist = ist_table[i];
2793
            av_free(ist);
2794
        }
2795
        av_free(ist_table);
2796
    }
2797
    if (ost_table) {
2798
        for(i=0;i<nb_ostreams;i++) {
2799
            ost = ost_table[i];
2800
            if (ost) {
2801
                if (ost->st->stream_copy)
2802
                    av_freep(&ost->st->codec->extradata);
2803
                if (ost->logfile) {
2804
                    fclose(ost->logfile);
2805
                    ost->logfile = NULL;
2806
                }
2807
                av_fifo_free(ost->fifo); /* works even if fifo is not
2808
                                             initialized but set to zero */
2809
                av_freep(&ost->st->codec->subtitle_header);
2810
                av_free(ost->pict_tmp.data[0]);
2811
                av_free(ost->forced_kf_pts);
2812
                if (ost->video_resample)
2813
                    sws_freeContext(ost->img_resample_ctx);
2814
                if (ost->resample)
2815
                    audio_resample_close(ost->resample);
2816
                if (ost->reformat_ctx)
2817
                    av_audio_convert_free(ost->reformat_ctx);
2818
                av_free(ost);
2819
            }
2820
        }
2821
        av_free(ost_table);
2822
    }
2823
    return ret;
2824
}
2825

    
2826
static void opt_format(const char *arg)
2827
{
2828
    last_asked_format = arg;
2829
}
2830

    
2831
static void opt_video_rc_override_string(const char *arg)
2832
{
2833
    video_rc_override_string = arg;
2834
}
2835

    
2836
static int opt_me_threshold(const char *opt, const char *arg)
2837
{
2838
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2839
    return 0;
2840
}
2841

    
2842
static int opt_verbose(const char *opt, const char *arg)
2843
{
2844
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2845
    return 0;
2846
}
2847

    
2848
static int opt_frame_rate(const char *opt, const char *arg)
2849
{
2850
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2851
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2852
        ffmpeg_exit(1);
2853
    }
2854
    return 0;
2855
}
2856

    
2857
static int opt_bitrate(const char *opt, const char *arg)
2858
{
2859
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2860

    
2861
    opt_default(opt, arg);
2862

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

    
2866
    return 0;
2867
}
2868

    
2869
static int opt_frame_crop(const char *opt, const char *arg)
2870
{
2871
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2872
    return AVERROR(EINVAL);
2873
}
2874

    
2875
static void opt_frame_size(const char *arg)
2876
{
2877
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2878
        fprintf(stderr, "Incorrect frame size\n");
2879
        ffmpeg_exit(1);
2880
    }
2881
}
2882

    
2883
static int opt_pad(const char *opt, const char *arg) {
2884
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2885
    return -1;
2886
}
2887

    
2888
static void opt_frame_pix_fmt(const char *arg)
2889
{
2890
    if (strcmp(arg, "list")) {
2891
        frame_pix_fmt = av_get_pix_fmt(arg);
2892
        if (frame_pix_fmt == PIX_FMT_NONE) {
2893
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2894
            ffmpeg_exit(1);
2895
        }
2896
    } else {
2897
        show_pix_fmts();
2898
        ffmpeg_exit(0);
2899
    }
2900
}
2901

    
2902
static void opt_frame_aspect_ratio(const char *arg)
2903
{
2904
    int x = 0, y = 0;
2905
    double ar = 0;
2906
    const char *p;
2907
    char *end;
2908

    
2909
    p = strchr(arg, ':');
2910
    if (p) {
2911
        x = strtol(arg, &end, 10);
2912
        if (end == p)
2913
            y = strtol(end+1, &end, 10);
2914
        if (x > 0 && y > 0)
2915
            ar = (double)x / (double)y;
2916
    } else
2917
        ar = strtod(arg, NULL);
2918

    
2919
    if (!ar) {
2920
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2921
        ffmpeg_exit(1);
2922
    }
2923
    frame_aspect_ratio = ar;
2924
}
2925

    
2926
static int opt_metadata(const char *opt, const char *arg)
2927
{
2928
    char *mid= strchr(arg, '=');
2929

    
2930
    if(!mid){
2931
        fprintf(stderr, "Missing =\n");
2932
        ffmpeg_exit(1);
2933
    }
2934
    *mid++= 0;
2935

    
2936
    av_metadata_set2(&metadata, arg, mid, 0);
2937

    
2938
    return 0;
2939
}
2940

    
2941
static int opt_qscale(const char *opt, const char *arg)
2942
{
2943
    video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2944
    if (video_qscale <= 0 || video_qscale > 255) {
2945
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2946
        return AVERROR(EINVAL);
2947
    }
2948
    return 0;
2949
}
2950

    
2951
static int opt_top_field_first(const char *opt, const char *arg)
2952
{
2953
    top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2954
    return 0;
2955
}
2956

    
2957
static int opt_thread_count(const char *opt, const char *arg)
2958
{
2959
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2960
#if !HAVE_THREADS
2961
    if (verbose >= 0)
2962
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2963
#endif
2964
    return 0;
2965
}
2966

    
2967
static void opt_audio_sample_fmt(const char *arg)
2968
{
2969
    if (strcmp(arg, "list")) {
2970
        audio_sample_fmt = av_get_sample_fmt(arg);
2971
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2972
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2973
            ffmpeg_exit(1);
2974
        }
2975
    } else {
2976
        int i;
2977
        char fmt_str[128];
2978
        for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2979
            printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2980
        ffmpeg_exit(0);
2981
    }
2982
}
2983

    
2984
static int opt_audio_rate(const char *opt, const char *arg)
2985
{
2986
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2987
    return 0;
2988
}
2989

    
2990
static int opt_audio_channels(const char *opt, const char *arg)
2991
{
2992
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2993
    return 0;
2994
}
2995

    
2996
static int opt_video_channel(const char *opt, const char *arg)
2997
{
2998
    video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2999
    return 0;
3000
}
3001

    
3002
static void opt_video_standard(const char *arg)
3003
{
3004
    video_standard = av_strdup(arg);
3005
}
3006

    
3007
static void opt_codec(int *pstream_copy, char **pcodec_name,
3008
                      int codec_type, const char *arg)
3009
{
3010
    av_freep(pcodec_name);
3011
    if (!strcmp(arg, "copy")) {
3012
        *pstream_copy = 1;
3013
    } else {
3014
        *pcodec_name = av_strdup(arg);
3015
    }
3016
}
3017

    
3018
static void opt_audio_codec(const char *arg)
3019
{
3020
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
3021
}
3022

    
3023
static void opt_video_codec(const char *arg)
3024
{
3025
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
3026
}
3027

    
3028
static void opt_subtitle_codec(const char *arg)
3029
{
3030
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3031
}
3032

    
3033
static int opt_codec_tag(const char *opt, const char *arg)
3034
{
3035
    char *tail;
3036
    uint32_t *codec_tag;
3037

    
3038
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3039
                !strcmp(opt, "vtag") ? &video_codec_tag :
3040
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3041
    if (!codec_tag)
3042
        return -1;
3043

    
3044
    *codec_tag = strtol(arg, &tail, 0);
3045
    if (!tail || *tail)
3046
        *codec_tag = AV_RL32(arg);
3047

    
3048
    return 0;
3049
}
3050

    
3051
static void opt_map(const char *arg)
3052
{
3053
    AVStreamMap *m;
3054
    char *p;
3055

    
3056
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3057
    m = &stream_maps[nb_stream_maps-1];
3058

    
3059
    m->file_index = strtol(arg, &p, 0);
3060
    if (*p)
3061
        p++;
3062

    
3063
    m->stream_index = strtol(p, &p, 0);
3064
    if (*p) {
3065
        p++;
3066
        m->sync_file_index = strtol(p, &p, 0);
3067
        if (*p)
3068
            p++;
3069
        m->sync_stream_index = strtol(p, &p, 0);
3070
    } else {
3071
        m->sync_file_index = m->file_index;
3072
        m->sync_stream_index = m->stream_index;
3073
    }
3074
}
3075

    
3076
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3077
{
3078
    *endptr = arg;
3079
    if (*arg == ',') {
3080
        *type = *(++arg);
3081
        switch (*arg) {
3082
        case 'g':
3083
            break;
3084
        case 's':
3085
        case 'c':
3086
        case 'p':
3087
            *index = strtol(++arg, endptr, 0);
3088
            break;
3089
        default:
3090
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3091
            ffmpeg_exit(1);
3092
        }
3093
    } else
3094
        *type = 'g';
3095
}
3096

    
3097
static void opt_map_metadata(const char *arg)
3098
{
3099
    AVMetaDataMap *m, *m1;
3100
    char *p;
3101

    
3102
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3103
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3104

    
3105
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3106
    m->file = strtol(arg, &p, 0);
3107
    parse_meta_type(p, &m->type, &m->index, &p);
3108
    if (*p)
3109
        p++;
3110

    
3111
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3112
    m1->file = strtol(p, &p, 0);
3113
    parse_meta_type(p, &m1->type, &m1->index, &p);
3114

    
3115
    if (m->type == 'g' || m1->type == 'g')
3116
        metadata_global_autocopy = 0;
3117
    if (m->type == 's' || m1->type == 's')
3118
        metadata_streams_autocopy = 0;
3119
    if (m->type == 'c' || m1->type == 'c')
3120
        metadata_chapters_autocopy = 0;
3121
}
3122

    
3123
static void opt_map_meta_data(const char *arg)
3124
{
3125
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3126
                    "Use -map_metadata instead.\n");
3127
    opt_map_metadata(arg);
3128
}
3129

    
3130
static void opt_map_chapters(const char *arg)
3131
{
3132
    AVChapterMap *c;
3133
    char *p;
3134

    
3135
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3136
                              nb_chapter_maps + 1);
3137
    c = &chapter_maps[nb_chapter_maps - 1];
3138
    c->out_file = strtol(arg, &p, 0);
3139
    if (*p)
3140
        p++;
3141

    
3142
    c->in_file = strtol(p, &p, 0);
3143
}
3144

    
3145
static void opt_input_ts_scale(const char *arg)
3146
{
3147
    unsigned int stream;
3148
    double scale;
3149
    char *p;
3150

    
3151
    stream = strtol(arg, &p, 0);
3152
    if (*p)
3153
        p++;
3154
    scale= strtod(p, &p);
3155

    
3156
    if(stream >= MAX_STREAMS)
3157
        ffmpeg_exit(1);
3158

    
3159
    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);
3160
    input_files_ts_scale[nb_input_files][stream]= scale;
3161
}
3162

    
3163
static int opt_recording_time(const char *opt, const char *arg)
3164
{
3165
    recording_time = parse_time_or_die(opt, arg, 1);
3166
    return 0;
3167
}
3168

    
3169
static int opt_start_time(const char *opt, const char *arg)
3170
{
3171
    start_time = parse_time_or_die(opt, arg, 1);
3172
    return 0;
3173
}
3174

    
3175
static int opt_recording_timestamp(const char *opt, const char *arg)
3176
{
3177
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3178
    return 0;
3179
}
3180

    
3181
static int opt_input_ts_offset(const char *opt, const char *arg)
3182
{
3183
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3184
    return 0;
3185
}
3186

    
3187
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3188
{
3189
    const char *codec_string = encoder ? "encoder" : "decoder";
3190
    AVCodec *codec;
3191

    
3192
    if(!name)
3193
        return CODEC_ID_NONE;
3194
    codec = encoder ?
3195
        avcodec_find_encoder_by_name(name) :
3196
        avcodec_find_decoder_by_name(name);
3197
    if(!codec) {
3198
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3199
        ffmpeg_exit(1);
3200
    }
3201
    if(codec->type != type) {
3202
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3203
        ffmpeg_exit(1);
3204
    }
3205
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3206
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3207
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3208
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3209
                codec_string, codec->name);
3210
        codec = encoder ?
3211
            avcodec_find_encoder(codec->id) :
3212
            avcodec_find_decoder(codec->id);
3213
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3214
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3215
                    codec_string, codec->name);
3216
        ffmpeg_exit(1);
3217
    }
3218
    return codec->id;
3219
}
3220

    
3221
static void opt_input_file(const char *filename)
3222
{
3223
    AVFormatContext *ic;
3224
    AVFormatParameters params, *ap = &params;
3225
    AVInputFormat *file_iformat = NULL;
3226
    int err, i, ret, rfps, rfps_base;
3227
    int64_t timestamp;
3228

    
3229
    if (last_asked_format) {
3230
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3231
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3232
            ffmpeg_exit(1);
3233
        }
3234
        last_asked_format = NULL;
3235
    }
3236

    
3237
    if (!strcmp(filename, "-"))
3238
        filename = "pipe:";
3239

    
3240
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3241
                    !strcmp(filename, "/dev/stdin");
3242

    
3243
    /* get default parameters from command line */
3244
    ic = avformat_alloc_context();
3245
    if (!ic) {
3246
        print_error(filename, AVERROR(ENOMEM));
3247
        ffmpeg_exit(1);
3248
    }
3249

    
3250
    memset(ap, 0, sizeof(*ap));
3251
    ap->prealloced_context = 1;
3252
    ap->sample_rate = audio_sample_rate;
3253
    ap->channels = audio_channels;
3254
    ap->time_base.den = frame_rate.num;
3255
    ap->time_base.num = frame_rate.den;
3256
    ap->width = frame_width;
3257
    ap->height = frame_height;
3258
    ap->pix_fmt = frame_pix_fmt;
3259
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3260
    ap->channel = video_channel;
3261
    ap->standard = video_standard;
3262

    
3263
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3264

    
3265
    ic->video_codec_id   =
3266
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3267
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3268
    ic->audio_codec_id   =
3269
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3270
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3271
    ic->subtitle_codec_id=
3272
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3273
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3274
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3275

    
3276
    /* open the input file with generic libav function */
3277
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3278
    if (err < 0) {
3279
        print_error(filename, err);
3280
        ffmpeg_exit(1);
3281
    }
3282
    if(opt_programid) {
3283
        int i, j;
3284
        int found=0;
3285
        for(i=0; i<ic->nb_streams; i++){
3286
            ic->streams[i]->discard= AVDISCARD_ALL;
3287
        }
3288
        for(i=0; i<ic->nb_programs; i++){
3289
            AVProgram *p= ic->programs[i];
3290
            if(p->id != opt_programid){
3291
                p->discard = AVDISCARD_ALL;
3292
            }else{
3293
                found=1;
3294
                for(j=0; j<p->nb_stream_indexes; j++){
3295
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3296
                }
3297
            }
3298
        }
3299
        if(!found){
3300
            fprintf(stderr, "Specified program id not found\n");
3301
            ffmpeg_exit(1);
3302
        }
3303
        opt_programid=0;
3304
    }
3305

    
3306
    ic->loop_input = loop_input;
3307

    
3308
    /* If not enough info to get the stream parameters, we decode the
3309
       first frames to get it. (used in mpeg case for example) */
3310
    ret = av_find_stream_info(ic);
3311
    if (ret < 0 && verbose >= 0) {
3312
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3313
        av_close_input_file(ic);
3314
        ffmpeg_exit(1);
3315
    }
3316

    
3317
    timestamp = start_time;
3318
    /* add the stream start time */
3319
    if (ic->start_time != AV_NOPTS_VALUE)
3320
        timestamp += ic->start_time;
3321

    
3322
    /* if seeking requested, we execute it */
3323
    if (start_time != 0) {
3324
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3325
        if (ret < 0) {
3326
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3327
                    filename, (double)timestamp / AV_TIME_BASE);
3328
        }
3329
        /* reset seek info */
3330
        start_time = 0;
3331
    }
3332

    
3333
    /* update the current parameters so that they match the one of the input stream */
3334
    for(i=0;i<ic->nb_streams;i++) {
3335
        AVStream *st = ic->streams[i];
3336
        AVCodecContext *dec = st->codec;
3337
        dec->thread_count = thread_count;
3338
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3339
        switch (dec->codec_type) {
3340
        case AVMEDIA_TYPE_AUDIO:
3341
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3342
            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]);
3343
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3344
            channel_layout    = dec->channel_layout;
3345
            audio_channels    = dec->channels;
3346
            audio_sample_rate = dec->sample_rate;
3347
            audio_sample_fmt  = dec->sample_fmt;
3348
            if(audio_disable)
3349
                st->discard= AVDISCARD_ALL;
3350
            /* Note that av_find_stream_info can add more streams, and we
3351
             * currently have no chance of setting up lowres decoding
3352
             * early enough for them. */
3353
            if (dec->lowres)
3354
                audio_sample_rate >>= dec->lowres;
3355
            break;
3356
        case AVMEDIA_TYPE_VIDEO:
3357
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3358
            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]);
3359
            frame_height = dec->height;
3360
            frame_width  = dec->width;
3361
            frame_pix_fmt = dec->pix_fmt;
3362
            rfps      = ic->streams[i]->r_frame_rate.num;
3363
            rfps_base = ic->streams[i]->r_frame_rate.den;
3364
            if (dec->lowres) {
3365
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3366
                frame_height >>= dec->lowres;
3367
                frame_width  >>= dec->lowres;
3368
                dec->height = frame_height;
3369
                dec->width  = frame_width;
3370
            }
3371
            if(me_threshold)
3372
                dec->debug |= FF_DEBUG_MV;
3373

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

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

    
3380
                    (float)rfps / rfps_base, rfps, rfps_base);
3381
            }
3382
            /* update the current frame rate to match the stream frame rate */
3383
            frame_rate.num = rfps;
3384
            frame_rate.den = rfps_base;
3385

    
3386
            if(video_disable)
3387
                st->discard= AVDISCARD_ALL;
3388
            else if(video_discard)
3389
                st->discard= video_discard;
3390
            break;
3391
        case AVMEDIA_TYPE_DATA:
3392
            break;
3393
        case AVMEDIA_TYPE_SUBTITLE:
3394
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3395
            if(subtitle_disable)
3396
                st->discard = AVDISCARD_ALL;
3397
            break;
3398
        case AVMEDIA_TYPE_ATTACHMENT:
3399
        case AVMEDIA_TYPE_UNKNOWN:
3400
            break;
3401
        default:
3402
            abort();
3403
        }
3404
    }
3405

    
3406
    input_files[nb_input_files] = ic;
3407
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3408
    /* dump the file content */
3409
    if (verbose >= 0)
3410
        av_dump_format(ic, nb_input_files, filename, 0);
3411

    
3412
    nb_input_files++;
3413

    
3414
    video_channel = 0;
3415

    
3416
    av_freep(&video_codec_name);
3417
    av_freep(&audio_codec_name);
3418
    av_freep(&subtitle_codec_name);
3419
}
3420

    
3421
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3422
                                         int *has_subtitle_ptr)
3423
{
3424
    int has_video, has_audio, has_subtitle, i, j;
3425
    AVFormatContext *ic;
3426

    
3427
    has_video = 0;
3428
    has_audio = 0;
3429
    has_subtitle = 0;
3430
    for(j=0;j<nb_input_files;j++) {
3431
        ic = input_files[j];
3432
        for(i=0;i<ic->nb_streams;i++) {
3433
            AVCodecContext *enc = ic->streams[i]->codec;
3434
            switch(enc->codec_type) {
3435
            case AVMEDIA_TYPE_AUDIO:
3436
                has_audio = 1;
3437
                break;
3438
            case AVMEDIA_TYPE_VIDEO:
3439
                has_video = 1;
3440
                break;
3441
            case AVMEDIA_TYPE_SUBTITLE:
3442
                has_subtitle = 1;
3443
                break;
3444
            case AVMEDIA_TYPE_DATA:
3445
            case AVMEDIA_TYPE_ATTACHMENT:
3446
            case AVMEDIA_TYPE_UNKNOWN:
3447
                break;
3448
            default:
3449
                abort();
3450
            }
3451
        }
3452
    }
3453
    *has_video_ptr = has_video;
3454
    *has_audio_ptr = has_audio;
3455
    *has_subtitle_ptr = has_subtitle;
3456
}
3457

    
3458
static void new_video_stream(AVFormatContext *oc, int file_idx)
3459
{
3460
    AVStream *st;
3461
    AVOutputStream *ost;
3462
    AVCodecContext *video_enc;
3463
    enum CodecID codec_id = CODEC_ID_NONE;
3464
    AVCodec *codec= NULL;
3465

    
3466
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3467
    if (!st) {
3468
        fprintf(stderr, "Could not alloc stream\n");
3469
        ffmpeg_exit(1);
3470
    }
3471
    ost = new_output_stream(oc, file_idx);
3472

    
3473
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3474
    if(!video_stream_copy){
3475
        if (video_codec_name) {
3476
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3477
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3478
            codec = avcodec_find_encoder_by_name(video_codec_name);
3479
            output_codecs[nb_output_codecs-1] = codec;
3480
        } else {
3481
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3482
            codec = avcodec_find_encoder(codec_id);
3483
        }
3484
        ost->frame_aspect_ratio = frame_aspect_ratio;
3485
        frame_aspect_ratio = 0;
3486
#if CONFIG_AVFILTER
3487
        ost->avfilter= vfilters;
3488
        vfilters= NULL;
3489
#endif
3490
    }
3491

    
3492
    avcodec_get_context_defaults3(st->codec, codec);
3493
    ost->bitstream_filters = video_bitstream_filters;
3494
    video_bitstream_filters= NULL;
3495

    
3496
    st->codec->thread_count= thread_count;
3497

    
3498
    video_enc = st->codec;
3499

    
3500
    if(video_codec_tag)
3501
        video_enc->codec_tag= video_codec_tag;
3502

    
3503
    if(   (video_global_header&1)
3504
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3505
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3506
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3507
    }
3508
    if(video_global_header&2){
3509
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3510
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3511
    }
3512

    
3513
    if (video_stream_copy) {
3514
        st->stream_copy = 1;
3515
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3516
        video_enc->sample_aspect_ratio =
3517
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3518
    } else {
3519
        const char *p;
3520
        int i;
3521
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3522

    
3523
        video_enc->codec_id = codec_id;
3524
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3525

    
3526
        if (codec && codec->supported_framerates && !force_fps)
3527
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3528
        video_enc->time_base.den = fps.num;
3529
        video_enc->time_base.num = fps.den;
3530

    
3531
        video_enc->width = frame_width;
3532
        video_enc->height = frame_height;
3533
        video_enc->pix_fmt = frame_pix_fmt;
3534
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3535
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3536

    
3537
        choose_pixel_fmt(st, codec);
3538

    
3539
        if (intra_only)
3540
            video_enc->gop_size = 0;
3541
        if (video_qscale || same_quality) {
3542
            video_enc->flags |= CODEC_FLAG_QSCALE;
3543
            video_enc->global_quality=
3544
                st->quality = FF_QP2LAMBDA * video_qscale;
3545
        }
3546

    
3547
        if(intra_matrix)
3548
            video_enc->intra_matrix = intra_matrix;
3549
        if(inter_matrix)
3550
            video_enc->inter_matrix = inter_matrix;
3551

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

    
3582
        if (do_psnr)
3583
            video_enc->flags|= CODEC_FLAG_PSNR;
3584

    
3585
        /* two pass mode */
3586
        if (do_pass) {
3587
            if (do_pass == 1) {
3588
                video_enc->flags |= CODEC_FLAG_PASS1;
3589
            } else {
3590
                video_enc->flags |= CODEC_FLAG_PASS2;
3591
            }
3592
        }
3593

    
3594
        if (forced_key_frames)
3595
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3596
    }
3597
    if (video_language) {
3598
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3599
        av_freep(&video_language);
3600
    }
3601

    
3602
    /* reset some key parameters */
3603
    video_disable = 0;
3604
    av_freep(&video_codec_name);
3605
    av_freep(&forced_key_frames);
3606
    video_stream_copy = 0;
3607
    frame_pix_fmt = PIX_FMT_NONE;
3608
}
3609

    
3610
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3611
{
3612
    AVStream *st;
3613
    AVOutputStream *ost;
3614
    AVCodec *codec= NULL;
3615
    AVCodecContext *audio_enc;
3616
    enum CodecID codec_id = CODEC_ID_NONE;
3617

    
3618
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3619
    if (!st) {
3620
        fprintf(stderr, "Could not alloc stream\n");
3621
        ffmpeg_exit(1);
3622
    }
3623
    ost = new_output_stream(oc, file_idx);
3624

    
3625
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3626
    if(!audio_stream_copy){
3627
        if (audio_codec_name) {
3628
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3629
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3630
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3631
            output_codecs[nb_output_codecs-1] = codec;
3632
        } else {
3633
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3634
            codec = avcodec_find_encoder(codec_id);
3635
        }
3636
    }
3637

    
3638
    avcodec_get_context_defaults3(st->codec, codec);
3639

    
3640
    ost->bitstream_filters = audio_bitstream_filters;
3641
    audio_bitstream_filters= NULL;
3642

    
3643
    st->codec->thread_count= thread_count;
3644

    
3645
    audio_enc = st->codec;
3646
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3647

    
3648
    if(audio_codec_tag)
3649
        audio_enc->codec_tag= audio_codec_tag;
3650

    
3651
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3652
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3653
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3654
    }
3655
    if (audio_stream_copy) {
3656
        st->stream_copy = 1;
3657
        audio_enc->channels = audio_channels;
3658
        audio_enc->sample_rate = audio_sample_rate;
3659
    } else {
3660
        audio_enc->codec_id = codec_id;
3661
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3662

    
3663
        if (audio_qscale > QSCALE_NONE) {
3664
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3665
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3666
        }
3667
        audio_enc->channels = audio_channels;
3668
        audio_enc->sample_fmt = audio_sample_fmt;
3669
        audio_enc->sample_rate = audio_sample_rate;
3670
        audio_enc->channel_layout = channel_layout;
3671
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3672
            audio_enc->channel_layout = 0;
3673
        choose_sample_fmt(st, codec);
3674
        choose_sample_rate(st, codec);
3675
    }
3676
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3677
    if (audio_language) {
3678
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3679
        av_freep(&audio_language);
3680
    }
3681

    
3682
    /* reset some key parameters */
3683
    audio_disable = 0;
3684
    av_freep(&audio_codec_name);
3685
    audio_stream_copy = 0;
3686
}
3687

    
3688
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3689
{
3690
    AVStream *st;
3691
    AVOutputStream *ost;
3692
    AVCodec *codec=NULL;
3693
    AVCodecContext *subtitle_enc;
3694
    enum CodecID codec_id = CODEC_ID_NONE;
3695

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

    
3716
    ost->bitstream_filters = subtitle_bitstream_filters;
3717
    subtitle_bitstream_filters= NULL;
3718

    
3719
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3720

    
3721
    if(subtitle_codec_tag)
3722
        subtitle_enc->codec_tag= subtitle_codec_tag;
3723

    
3724
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3725
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3726
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3727
    }
3728
    if (subtitle_stream_copy) {
3729
        st->stream_copy = 1;
3730
    } else {
3731
        subtitle_enc->codec_id = codec_id;
3732
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3733
    }
3734

    
3735
    if (subtitle_language) {
3736
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3737
        av_freep(&subtitle_language);
3738
    }
3739

    
3740
    subtitle_disable = 0;
3741
    av_freep(&subtitle_codec_name);
3742
    subtitle_stream_copy = 0;
3743
}
3744

    
3745
static int opt_new_stream(const char *opt, const char *arg)
3746
{
3747
    AVFormatContext *oc;
3748
    int file_idx = nb_output_files - 1;
3749
    if (nb_output_files <= 0) {
3750
        fprintf(stderr, "At least one output file must be specified\n");
3751
        ffmpeg_exit(1);
3752
    }
3753
    oc = output_files[file_idx];
3754

    
3755
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3756
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3757
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3758
    else av_assert0(0);
3759
    return 0;
3760
}
3761

    
3762
/* arg format is "output-stream-index:streamid-value". */
3763
static int opt_streamid(const char *opt, const char *arg)
3764
{
3765
    int idx;
3766
    char *p;
3767
    char idx_str[16];
3768

    
3769
    strncpy(idx_str, arg, sizeof(idx_str));
3770
    idx_str[sizeof(idx_str)-1] = '\0';
3771
    p = strchr(idx_str, ':');
3772
    if (!p) {
3773
        fprintf(stderr,
3774
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3775
                arg, opt);
3776
        ffmpeg_exit(1);
3777
    }
3778
    *p++ = '\0';
3779
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3780
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3781
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3782
    return 0;
3783
}
3784

    
3785
static void opt_output_file(const char *filename)
3786
{
3787
    AVFormatContext *oc;
3788
    int err, use_video, use_audio, use_subtitle;
3789
    int input_has_video, input_has_audio, input_has_subtitle;
3790
    AVFormatParameters params, *ap = &params;
3791
    AVOutputFormat *file_oformat;
3792

    
3793
    if (!strcmp(filename, "-"))
3794
        filename = "pipe:";
3795

    
3796
    oc = avformat_alloc_context();
3797
    if (!oc) {
3798
        print_error(filename, AVERROR(ENOMEM));
3799
        ffmpeg_exit(1);
3800
    }
3801

    
3802
    if (last_asked_format) {
3803
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3804
        if (!file_oformat) {
3805
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3806
            ffmpeg_exit(1);
3807
        }
3808
        last_asked_format = NULL;
3809
    } else {
3810
        file_oformat = av_guess_format(NULL, filename, NULL);
3811
        if (!file_oformat) {
3812
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3813
                    filename);
3814
            ffmpeg_exit(1);
3815
        }
3816
    }
3817

    
3818
    oc->oformat = file_oformat;
3819
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3820

    
3821
    if (!strcmp(file_oformat->name, "ffm") &&
3822
        av_strstart(filename, "http:", NULL)) {
3823
        /* special case for files sent to ffserver: we get the stream
3824
           parameters from ffserver */
3825
        int err = read_ffserver_streams(oc, filename);
3826
        if (err < 0) {
3827
            print_error(filename, err);
3828
            ffmpeg_exit(1);
3829
        }
3830
    } else {
3831
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3832
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3833
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3834

    
3835
        /* disable if no corresponding type found and at least one
3836
           input file */
3837
        if (nb_input_files > 0) {
3838
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3839
                                         &input_has_subtitle);
3840
            if (!input_has_video)
3841
                use_video = 0;
3842
            if (!input_has_audio)
3843
                use_audio = 0;
3844
            if (!input_has_subtitle)
3845
                use_subtitle = 0;
3846
        }
3847

    
3848
        /* manual disable */
3849
        if (audio_disable)    use_audio    = 0;
3850
        if (video_disable)    use_video    = 0;
3851
        if (subtitle_disable) use_subtitle = 0;
3852

    
3853
        if (use_video)    new_video_stream(oc, nb_output_files);
3854
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3855
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3856

    
3857
        oc->timestamp = recording_timestamp;
3858

    
3859
        av_metadata_copy(&oc->metadata, metadata, 0);
3860
        av_metadata_free(&metadata);
3861
    }
3862

    
3863
    output_files[nb_output_files++] = oc;
3864

    
3865
    /* check filename in case of an image number is expected */
3866
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3867
        if (!av_filename_number_test(oc->filename)) {
3868
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3869
            ffmpeg_exit(1);
3870
        }
3871
    }
3872

    
3873
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3874
        /* test if it already exists to avoid loosing precious files */
3875
        if (!file_overwrite &&
3876
            (strchr(filename, ':') == NULL ||
3877
             filename[1] == ':' ||
3878
             av_strstart(filename, "file:", NULL))) {
3879
            if (url_exist(filename)) {
3880
                if (!using_stdin) {
3881
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3882
                    fflush(stderr);
3883
                    if (!read_yesno()) {
3884
                        fprintf(stderr, "Not overwriting - exiting\n");
3885
                        ffmpeg_exit(1);
3886
                    }
3887
                }
3888
                else {
3889
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3890
                    ffmpeg_exit(1);
3891
                }
3892
            }
3893
        }
3894

    
3895
        /* open the file */
3896
        if ((err = avio_open(&oc->pb, filename, AVIO_WRONLY)) < 0) {
3897
            print_error(filename, err);
3898
            ffmpeg_exit(1);
3899
        }
3900
    }
3901

    
3902
    memset(ap, 0, sizeof(*ap));
3903
    if (av_set_parameters(oc, ap) < 0) {
3904
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3905
                oc->filename);
3906
        ffmpeg_exit(1);
3907
    }
3908

    
3909
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3910
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3911
    oc->loop_output = loop_output;
3912

    
3913
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3914

    
3915
    av_freep(&forced_key_frames);
3916
}
3917

    
3918
/* same option as mencoder */
3919
static int opt_pass(const char *opt, const char *arg)
3920
{
3921
    do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3922
    return 0;
3923
}
3924

    
3925
static int64_t getutime(void)
3926
{
3927
#if HAVE_GETRUSAGE
3928
    struct rusage rusage;
3929

    
3930
    getrusage(RUSAGE_SELF, &rusage);
3931
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3932
#elif HAVE_GETPROCESSTIMES
3933
    HANDLE proc;
3934
    FILETIME c, e, k, u;
3935
    proc = GetCurrentProcess();
3936
    GetProcessTimes(proc, &c, &e, &k, &u);
3937
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3938
#else
3939
    return av_gettime();
3940
#endif
3941
}
3942

    
3943
static int64_t getmaxrss(void)
3944
{
3945
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3946
    struct rusage rusage;
3947
    getrusage(RUSAGE_SELF, &rusage);
3948
    return (int64_t)rusage.ru_maxrss * 1024;
3949
#elif HAVE_GETPROCESSMEMORYINFO
3950
    HANDLE proc;
3951
    PROCESS_MEMORY_COUNTERS memcounters;
3952
    proc = GetCurrentProcess();
3953
    memcounters.cb = sizeof(memcounters);
3954
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3955
    return memcounters.PeakPagefileUsage;
3956
#else
3957
    return 0;
3958
#endif
3959
}
3960

    
3961
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3962
{
3963
    int i;
3964
    const char *p = str;
3965
    for(i = 0;; i++) {
3966
        dest[i] = atoi(p);
3967
        if(i == 63)
3968
            break;
3969
        p = strchr(p, ',');
3970
        if(!p) {
3971
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3972
            ffmpeg_exit(1);
3973
        }
3974
        p++;
3975
    }
3976
}
3977

    
3978
static void opt_inter_matrix(const char *arg)
3979
{
3980
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3981
    parse_matrix_coeffs(inter_matrix, arg);
3982
}
3983

    
3984
static void opt_intra_matrix(const char *arg)
3985
{
3986
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3987
    parse_matrix_coeffs(intra_matrix, arg);
3988
}
3989

    
3990
static void show_usage(void)
3991
{
3992
    printf("Hyper fast Audio and Video encoder\n");
3993
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3994
    printf("\n");
3995
}
3996

    
3997
static void show_help(void)
3998
{
3999
    AVCodec *c;
4000
    AVOutputFormat *oformat = NULL;
4001

    
4002
    av_log_set_callback(log_callback_help);
4003
    show_usage();
4004
    show_help_options(options, "Main options:\n",
4005
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4006
    show_help_options(options, "\nAdvanced options:\n",
4007
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4008
                      OPT_EXPERT);
4009
    show_help_options(options, "\nVideo options:\n",
4010
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4011
                      OPT_VIDEO);
4012
    show_help_options(options, "\nAdvanced Video options:\n",
4013
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4014
                      OPT_VIDEO | OPT_EXPERT);
4015
    show_help_options(options, "\nAudio options:\n",
4016
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4017
                      OPT_AUDIO);
4018
    show_help_options(options, "\nAdvanced Audio options:\n",
4019
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4020
                      OPT_AUDIO | OPT_EXPERT);
4021
    show_help_options(options, "\nSubtitle options:\n",
4022
                      OPT_SUBTITLE | OPT_GRAB,
4023
                      OPT_SUBTITLE);
4024
    show_help_options(options, "\nAudio/Video grab options:\n",
4025
                      OPT_GRAB,
4026
                      OPT_GRAB);
4027
    printf("\n");
4028
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4029
    printf("\n");
4030

    
4031
    /* individual codec options */
4032
    c = NULL;
4033
    while ((c = av_codec_next(c))) {
4034
        if (c->priv_class) {
4035
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4036
            printf("\n");
4037
        }
4038
    }
4039

    
4040
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4041
    printf("\n");
4042

    
4043
    /* individual muxer options */
4044
    while ((oformat = av_oformat_next(oformat))) {
4045
        if (oformat->priv_class) {
4046
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4047
            printf("\n");
4048
        }
4049
    }
4050

    
4051
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4052
}
4053

    
4054
static void opt_target(const char *arg)
4055
{
4056
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4057
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4058

    
4059
    if(!strncmp(arg, "pal-", 4)) {
4060
        norm = PAL;
4061
        arg += 4;
4062
    } else if(!strncmp(arg, "ntsc-", 5)) {
4063
        norm = NTSC;
4064
        arg += 5;
4065
    } else if(!strncmp(arg, "film-", 5)) {
4066
        norm = FILM;
4067
        arg += 5;
4068
    } else {
4069
        int fr;
4070
        /* Calculate FR via float to avoid int overflow */
4071
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4072
        if(fr == 25000) {
4073
            norm = PAL;
4074
        } else if((fr == 29970) || (fr == 23976)) {
4075
            norm = NTSC;
4076
        } else {
4077
            /* Try to determine PAL/NTSC by peeking in the input files */
4078
            if(nb_input_files) {
4079
                int i, j;
4080
                for(j = 0; j < nb_input_files; j++) {
4081
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
4082
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
4083
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4084
                            continue;
4085
                        fr = c->time_base.den * 1000 / c->time_base.num;
4086
                        if(fr == 25000) {
4087
                            norm = PAL;
4088
                            break;
4089
                        } else if((fr == 29970) || (fr == 23976)) {
4090
                            norm = NTSC;
4091
                            break;
4092
                        }
4093
                    }
4094
                    if(norm != UNKNOWN)
4095
                        break;
4096
                }
4097
            }
4098
        }
4099
        if(verbose > 0 && norm != UNKNOWN)
4100
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4101
    }
4102

    
4103
    if(norm == UNKNOWN) {
4104
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4105
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4106
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4107
        ffmpeg_exit(1);
4108
    }
4109

    
4110
    if(!strcmp(arg, "vcd")) {
4111

    
4112
        opt_video_codec("mpeg1video");
4113
        opt_audio_codec("mp2");
4114
        opt_format("vcd");
4115

    
4116
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4117
        opt_frame_rate(NULL, frame_rates[norm]);
4118
        opt_default("g", norm == PAL ? "15" : "18");
4119

    
4120
        opt_default("b", "1150000");
4121
        opt_default("maxrate", "1150000");
4122
        opt_default("minrate", "1150000");
4123
        opt_default("bufsize", "327680"); // 40*1024*8;
4124

    
4125
        opt_default("ab", "224000");
4126
        audio_sample_rate = 44100;
4127
        audio_channels = 2;
4128

    
4129
        opt_default("packetsize", "2324");
4130
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4131

    
4132
        /* We have to offset the PTS, so that it is consistent with the SCR.
4133
           SCR starts at 36000, but the first two packs contain only padding
4134
           and the first pack from the other stream, respectively, may also have
4135
           been written before.
4136
           So the real data starts at SCR 36000+3*1200. */
4137
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4138
    } else if(!strcmp(arg, "svcd")) {
4139

    
4140
        opt_video_codec("mpeg2video");
4141
        opt_audio_codec("mp2");
4142
        opt_format("svcd");
4143

    
4144
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4145
        opt_frame_rate(NULL, frame_rates[norm]);
4146
        opt_default("g", norm == PAL ? "15" : "18");
4147

    
4148
        opt_default("b", "2040000");
4149
        opt_default("maxrate", "2516000");
4150
        opt_default("minrate", "0"); //1145000;
4151
        opt_default("bufsize", "1835008"); //224*1024*8;
4152
        opt_default("flags", "+scan_offset");
4153

    
4154

    
4155
        opt_default("ab", "224000");
4156
        audio_sample_rate = 44100;
4157

    
4158
        opt_default("packetsize", "2324");
4159

    
4160
    } else if(!strcmp(arg, "dvd")) {
4161

    
4162
        opt_video_codec("mpeg2video");
4163
        opt_audio_codec("ac3");
4164
        opt_format("dvd");
4165

    
4166
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4167
        opt_frame_rate(NULL, frame_rates[norm]);
4168
        opt_default("g", norm == PAL ? "15" : "18");
4169

    
4170
        opt_default("b", "6000000");
4171
        opt_default("maxrate", "9000000");
4172
        opt_default("minrate", "0"); //1500000;
4173
        opt_default("bufsize", "1835008"); //224*1024*8;
4174

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

    
4178
        opt_default("ab", "448000");
4179
        audio_sample_rate = 48000;
4180

    
4181
    } else if(!strncmp(arg, "dv", 2)) {
4182

    
4183
        opt_format("dv");
4184

    
4185
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4186
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4187
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4188
        opt_frame_rate(NULL, frame_rates[norm]);
4189

    
4190
        audio_sample_rate = 48000;
4191
        audio_channels = 2;
4192

    
4193
    } else {
4194
        fprintf(stderr, "Unknown target: %s\n", arg);
4195
        ffmpeg_exit(1);
4196
    }
4197
}
4198

    
4199
static void opt_vstats_file (const char *arg)
4200
{
4201
    av_free (vstats_filename);
4202
    vstats_filename=av_strdup (arg);
4203
}
4204

    
4205
static void opt_vstats (void)
4206
{
4207
    char filename[40];
4208
    time_t today2 = time(NULL);
4209
    struct tm *today = localtime(&today2);
4210

    
4211
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4212
             today->tm_sec);
4213
    opt_vstats_file(filename);
4214
}
4215

    
4216
static int opt_bsf(const char *opt, const char *arg)
4217
{
4218
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4219
    AVBitStreamFilterContext **bsfp;
4220

    
4221
    if(!bsfc){
4222
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4223
        ffmpeg_exit(1);
4224
    }
4225

    
4226
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4227
          *opt == 'a' ? &audio_bitstream_filters :
4228
                        &subtitle_bitstream_filters;
4229
    while(*bsfp)
4230
        bsfp= &(*bsfp)->next;
4231

    
4232
    *bsfp= bsfc;
4233

    
4234
    return 0;
4235
}
4236

    
4237
static int opt_preset(const char *opt, const char *arg)
4238
{
4239
    FILE *f=NULL;
4240
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4241
    char *codec_name = *opt == 'v' ? video_codec_name :
4242
                       *opt == 'a' ? audio_codec_name :
4243
                                     subtitle_codec_name;
4244

    
4245
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4246
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4247
        ffmpeg_exit(1);
4248
    }
4249

    
4250
    while(!feof(f)){
4251
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4252
        if(line[0] == '#' && !e)
4253
            continue;
4254
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4255
        if(e){
4256
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4257
            ffmpeg_exit(1);
4258
        }
4259
        if(!strcmp(tmp, "acodec")){
4260
            opt_audio_codec(tmp2);
4261
        }else if(!strcmp(tmp, "vcodec")){
4262
            opt_video_codec(tmp2);
4263
        }else if(!strcmp(tmp, "scodec")){
4264
            opt_subtitle_codec(tmp2);
4265
        }else if(opt_default(tmp, tmp2) < 0){
4266
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4267
            ffmpeg_exit(1);
4268
        }
4269
    }
4270

    
4271
    fclose(f);
4272

    
4273
    return 0;
4274
}
4275

    
4276
static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4277
{
4278
}
4279

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

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

    
4374
    /* audio options */
4375
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4376
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4377
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4378
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4379
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4380
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4381
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4382
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4383
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4384
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4385
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4386
    { "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" },
4387

    
4388
    /* subtitle options */
4389
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4390
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4391
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4392
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4393
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4394

    
4395
    /* grab options */
4396
    { "vc", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4397
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4398
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4399

    
4400
    /* muxer options */
4401
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4402
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4403

    
4404
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4405
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4406
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4407

    
4408
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4409
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4410
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4411
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4412

    
4413
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4414
    { NULL, },
4415
};
4416

    
4417
int main(int argc, char **argv)
4418
{
4419
    int64_t ti;
4420

    
4421
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4422

    
4423
    if(argc>1 && !strcmp(argv[1], "-d")){
4424
        daemon=1;
4425
        verbose=-1;
4426
        av_log_set_callback(log_callback_null);
4427
        argc--;
4428
        argv++;
4429
    }
4430

    
4431
    avcodec_register_all();
4432
#if CONFIG_AVDEVICE
4433
    avdevice_register_all();
4434
#endif
4435
#if CONFIG_AVFILTER
4436
    avfilter_register_all();
4437
#endif
4438
    av_register_all();
4439

    
4440
#if HAVE_ISATTY
4441
    if(isatty(STDIN_FILENO))
4442
        avio_set_interrupt_cb(decode_interrupt_cb);
4443
#endif
4444

    
4445
    init_opts();
4446

    
4447
    show_banner();
4448

    
4449
    /* parse options */
4450
    parse_options(argc, argv, options, opt_output_file);
4451

    
4452
    if(nb_output_files <= 0 && nb_input_files == 0) {
4453
        show_usage();
4454
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4455
        ffmpeg_exit(1);
4456
    }
4457

    
4458
    /* file converter / grab */
4459
    if (nb_output_files <= 0) {
4460
        fprintf(stderr, "At least one output file must be specified\n");
4461
        ffmpeg_exit(1);
4462
    }
4463

    
4464
    if (nb_input_files == 0) {
4465
        fprintf(stderr, "At least one input file must be specified\n");
4466
        ffmpeg_exit(1);
4467
    }
4468

    
4469
    ti = getutime();
4470
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4471
                  stream_maps, nb_stream_maps) < 0)
4472
        ffmpeg_exit(1);
4473
    ti = getutime() - ti;
4474
    if (do_benchmark) {
4475
        int maxrss = getmaxrss() / 1024;
4476
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4477
    }
4478

    
4479
    return ffmpeg_exit(0);
4480
}