Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 3ee53dab

History | View | Annotate | Download (159 KB)

1
/*
2
 * FFmpeg main
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; 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
#if CONFIG_AVFILTER
51
# include "libavfilter/avfilter.h"
52
# include "libavfilter/avfiltergraph.h"
53
# include "libavfilter/vsrc_buffer.h"
54
#endif
55

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

    
68
#if HAVE_SYS_SELECT_H
69
#include <sys/select.h>
70
#endif
71

    
72
#if HAVE_KBHIT
73
#include <conio.h>
74
#endif
75
#include <time.h>
76

    
77
#include "cmdutils.h"
78

    
79
#include "libavutil/avassert.h"
80

    
81
const char program_name[] = "FFmpeg";
82
const int program_birth_year = 2000;
83

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

    
92
/**
93
 * select an input file for an output file
94
 */
95
typedef struct AVMetaDataMap {
96
    int  file;      //< file index
97
    char type;      //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
98
    int  index;     //< stream/chapter/program number
99
} AVMetaDataMap;
100

    
101
typedef struct AVChapterMap {
102
    int in_file;
103
    int out_file;
104
} AVChapterMap;
105

    
106
static const OptionDef options[];
107

    
108
#define MAX_FILES 100
109
#if !FF_API_MAX_STREAMS
110
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
111
#endif
112

    
113
#define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h
114

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

    
124
static AVFormatContext *output_files[MAX_FILES];
125
static AVCodec **output_codecs = NULL;
126
static int nb_output_files = 0;
127
static int nb_output_codecs = 0;
128

    
129
static AVStreamMap *stream_maps = NULL;
130
static int nb_stream_maps;
131

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

    
139
static AVChapterMap *chapter_maps = NULL;
140
static int nb_chapter_maps;
141

    
142
/* indexed by output file stream index */
143
static int *streamid_map = NULL;
144
static int nb_streamid_map = 0;
145

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

    
175
static int intra_only = 0;
176
static int audio_sample_rate = 44100;
177
static int64_t channel_layout = 0;
178
#define QSCALE_NONE -99999
179
static float audio_qscale = QSCALE_NONE;
180
static int audio_disable = 0;
181
static int audio_channels = 1;
182
static char  *audio_codec_name = NULL;
183
static unsigned int audio_codec_tag = 0;
184
static char *audio_language = NULL;
185

    
186
static int subtitle_disable = 0;
187
static char *subtitle_codec_name = NULL;
188
static char *subtitle_language = NULL;
189
static unsigned int subtitle_codec_tag = 0;
190

    
191
static float mux_preload= 0.5;
192
static float mux_max_delay= 0.7;
193

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

    
221
static int rate_emu = 0;
222

    
223
static int  video_channel = 0;
224
static char *video_standard;
225

    
226
static int audio_volume = 256;
227

    
228
static int exit_on_error = 0;
229
static int using_stdin = 0;
230
static int verbose = 1;
231
static int thread_count= 1;
232
static int q_pressed = 0;
233
static int64_t video_size = 0;
234
static int64_t audio_size = 0;
235
static int64_t extra_size = 0;
236
static int nb_frames_dup = 0;
237
static int nb_frames_drop = 0;
238
static int input_sync;
239
static uint64_t limit_filesize = 0;
240
static int force_fps = 0;
241
static char *forced_key_frames = NULL;
242

    
243
static float dts_delta_threshold = 10;
244

    
245
static unsigned int sws_flags = SWS_BICUBIC;
246

    
247
static int64_t timer_start;
248

    
249
static uint8_t *audio_buf;
250
static uint8_t *audio_out;
251
static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
252

    
253
static short *samples;
254

    
255
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
256
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
257
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
258

    
259
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
260

    
261
struct AVInputStream;
262

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

    
284
    /* full frame size of first frame */
285
    int original_height;
286
    int original_width;
287

    
288
    /* forced key frames */
289
    int64_t *forced_kf_pts;
290
    int forced_kf_count;
291
    int forced_kf_index;
292

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

    
305
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
306
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
307

    
308
typedef struct AVInputStream {
309
    int file_index;
310
    int index;
311
    AVStream *st;
312
    int discard;             /* true if stream data should be discarded */
313
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
314
    int64_t sample_index;      /* current sample */
315

    
316
    int64_t       start;     /* time when read started */
317
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
318
                                is not defined */
319
    int64_t       pts;       /* current pts */
320
    PtsCorrectionContext pts_ctx;
321
    int is_start;            /* is 1 at the start and after a discontinuity */
322
    int showed_multi_packet_warning;
323
    int is_past_recording_time;
324
#if CONFIG_AVFILTER
325
    AVFilterContext *output_video_filter;
326
    AVFilterContext *input_video_filter;
327
    AVFrame *filter_frame;
328
    int has_filter_frame;
329
    AVFilterBufferRef *picref;
330
#endif
331
} AVInputStream;
332

    
333
typedef struct AVInputFile {
334
    int eof_reached;      /* true if eof reached */
335
    int ist_index;        /* index of first stream in ist_table */
336
    int buffer_size;      /* current total buffer size */
337
    int nb_streams;       /* nb streams we are aware of */
338
} AVInputFile;
339

    
340
#if CONFIG_AVFILTER
341

    
342
static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
343
{
344
    AVFilterContext *last_filter, *filter;
345
    /** filter graph containing all filters including input & output */
346
    AVCodecContext *codec = ost->st->codec;
347
    AVCodecContext *icodec = ist->st->codec;
348
    FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
349
    char args[255];
350
    int ret;
351

    
352
    graph = avfilter_graph_alloc();
353

    
354
    snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
355
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
356
    ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
357
                                       "src", args, NULL, graph);
358
    if (ret < 0)
359
        return ret;
360
    ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
361
                                       "out", NULL, &ffsink_ctx, graph);
362
    if (ret < 0)
363
        return ret;
364
    last_filter = ist->input_video_filter;
365

    
366
    if (codec->width  != icodec->width || codec->height != icodec->height) {
367
        snprintf(args, 255, "%d:%d:flags=0x%X",
368
                 codec->width,
369
                 codec->height,
370
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
371
        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
372
                                                NULL, args, NULL, graph)) < 0)
373
            return ret;
374
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
375
            return ret;
376
        last_filter = filter;
377
    }
378

    
379
    snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
380
    graph->scale_sws_opts = av_strdup(args);
381

    
382
    if (vfilters) {
383
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
384
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
385

    
386
        outputs->name    = av_strdup("in");
387
        outputs->filter_ctx = last_filter;
388
        outputs->pad_idx = 0;
389
        outputs->next    = NULL;
390

    
391
        inputs->name    = av_strdup("out");
392
        inputs->filter_ctx = ist->output_video_filter;
393
        inputs->pad_idx = 0;
394
        inputs->next    = NULL;
395

    
396
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
397
            return ret;
398
        av_freep(&vfilters);
399
    } else {
400
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
401
            return ret;
402
    }
403

    
404
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
405
        return ret;
406

    
407
    codec->width  = ist->output_video_filter->inputs[0]->w;
408
    codec->height = ist->output_video_filter->inputs[0]->h;
409

    
410
    return 0;
411
}
412
#endif /* CONFIG_AVFILTER */
413

    
414
static void term_exit(void)
415
{
416
    av_log(NULL, AV_LOG_QUIET, "");
417
}
418

    
419
static volatile int received_sigterm = 0;
420

    
421
static void
422
sigterm_handler(int sig)
423
{
424
    received_sigterm = sig;
425
    term_exit();
426
}
427

    
428
static void term_init(void)
429
{
430
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
431
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
432
#ifdef SIGXCPU
433
    signal(SIGXCPU, sigterm_handler);
434
#endif
435
}
436

    
437
/* read a key without blocking */
438
static int read_key(void)
439
{
440
#if HAVE_KBHIT
441
    if(kbhit())
442
        return(getch());
443
#endif
444
    return -1;
445
}
446

    
447
static int decode_interrupt_cb(void)
448
{
449
    return q_pressed || (q_pressed = read_key() == 'q');
450
}
451

    
452
static int ffmpeg_exit(int ret)
453
{
454
    int i;
455

    
456
    /* close files */
457
    for(i=0;i<nb_output_files;i++) {
458
        AVFormatContext *s = output_files[i];
459
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
460
            avio_close(s->pb);
461
        avformat_free_context(s);
462
        av_free(output_streams_for_file[i]);
463
    }
464
    for(i=0;i<nb_input_files;i++) {
465
        av_close_input_file(input_files[i]);
466
        av_free(input_files_ts_scale[i]);
467
    }
468

    
469
    av_free(intra_matrix);
470
    av_free(inter_matrix);
471

    
472
    if (vstats_file)
473
        fclose(vstats_file);
474
    av_free(vstats_filename);
475

    
476
    av_free(streamid_map);
477
    av_free(input_codecs);
478
    av_free(output_codecs);
479
    av_free(stream_maps);
480
    av_free(meta_data_maps);
481

    
482
    av_free(video_codec_name);
483
    av_free(audio_codec_name);
484
    av_free(subtitle_codec_name);
485

    
486
    av_free(video_standard);
487

    
488
    uninit_opts();
489
    av_free(audio_buf);
490
    av_free(audio_out);
491
    allocated_audio_buf_size= allocated_audio_out_size= 0;
492
    av_free(samples);
493

    
494
#if CONFIG_AVFILTER
495
    avfilter_uninit();
496
#endif
497

    
498
    if (received_sigterm) {
499
        fprintf(stderr,
500
            "Received signal %d: terminating.\n",
501
            (int) received_sigterm);
502
        exit (255);
503
    }
504

    
505
    exit(ret); /* not all OS-es handle main() return value */
506
    return ret;
507
}
508

    
509
/* similar to ff_dynarray_add() and av_fast_realloc() */
510
static void *grow_array(void *array, int elem_size, int *size, int new_size)
511
{
512
    if (new_size >= INT_MAX / elem_size) {
513
        fprintf(stderr, "Array too big.\n");
514
        ffmpeg_exit(1);
515
    }
516
    if (*size < new_size) {
517
        uint8_t *tmp = av_realloc(array, new_size*elem_size);
518
        if (!tmp) {
519
            fprintf(stderr, "Could not alloc buffer.\n");
520
            ffmpeg_exit(1);
521
        }
522
        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
523
        *size = new_size;
524
        return tmp;
525
    }
526
    return array;
527
}
528

    
529
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
530
{
531
    if(codec && codec->sample_fmts){
532
        const enum AVSampleFormat *p= codec->sample_fmts;
533
        for(; *p!=-1; p++){
534
            if(*p == st->codec->sample_fmt)
535
                break;
536
        }
537
        if (*p == -1) {
538
            av_log(NULL, AV_LOG_WARNING,
539
                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
540
                   av_get_sample_fmt_name(st->codec->sample_fmt),
541
                   codec->name,
542
                   av_get_sample_fmt_name(codec->sample_fmts[0]));
543
            st->codec->sample_fmt = codec->sample_fmts[0];
544
        }
545
    }
546
}
547

    
548
static void choose_sample_rate(AVStream *st, AVCodec *codec)
549
{
550
    if(codec && codec->supported_samplerates){
551
        const int *p= codec->supported_samplerates;
552
        int best=0;
553
        int best_dist=INT_MAX;
554
        for(; *p; p++){
555
            int dist= abs(st->codec->sample_rate - *p);
556
            if(dist < best_dist){
557
                best_dist= dist;
558
                best= *p;
559
            }
560
        }
561
        if(best_dist){
562
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
563
        }
564
        st->codec->sample_rate= best;
565
    }
566
}
567

    
568
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
569
{
570
    if(codec && codec->pix_fmts){
571
        const enum PixelFormat *p= codec->pix_fmts;
572
        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
573
            if(st->codec->codec_id==CODEC_ID_MJPEG){
574
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
575
            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
576
                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};
577
            }
578
        }
579
        for(; *p!=-1; p++){
580
            if(*p == st->codec->pix_fmt)
581
                break;
582
        }
583
        if(*p == -1)
584
            st->codec->pix_fmt = codec->pix_fmts[0];
585
    }
586
}
587

    
588
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
589
{
590
    int idx = oc->nb_streams - 1;
591
    AVOutputStream *ost;
592

    
593
    output_streams_for_file[file_idx] =
594
        grow_array(output_streams_for_file[file_idx],
595
                   sizeof(*output_streams_for_file[file_idx]),
596
                   &nb_output_streams_for_file[file_idx],
597
                   oc->nb_streams);
598
    ost = output_streams_for_file[file_idx][idx] =
599
        av_mallocz(sizeof(AVOutputStream));
600
    if (!ost) {
601
        fprintf(stderr, "Could not alloc output stream\n");
602
        ffmpeg_exit(1);
603
    }
604
    ost->file_index = file_idx;
605
    ost->index = idx;
606
    return ost;
607
}
608

    
609
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
610
{
611
    int i, err;
612
    AVFormatContext *ic;
613
    int nopts = 0;
614

    
615
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
616
    if (err < 0)
617
        return err;
618
    /* copy stream format */
619
    s->nb_streams = 0;
620
    for(i=0;i<ic->nb_streams;i++) {
621
        AVStream *st;
622
        AVCodec *codec;
623

    
624
        s->nb_streams++;
625

    
626
        // FIXME: a more elegant solution is needed
627
        st = av_mallocz(sizeof(AVStream));
628
        memcpy(st, ic->streams[i], sizeof(AVStream));
629
        st->codec = avcodec_alloc_context();
630
        if (!st->codec) {
631
            print_error(filename, AVERROR(ENOMEM));
632
            ffmpeg_exit(1);
633
        }
634
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
635
        s->streams[i] = st;
636

    
637
        codec = avcodec_find_encoder(st->codec->codec_id);
638
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
639
            if (audio_stream_copy) {
640
                st->stream_copy = 1;
641
            } else
642
                choose_sample_fmt(st, codec);
643
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
644
            if (video_stream_copy) {
645
                st->stream_copy = 1;
646
            } else
647
                choose_pixel_fmt(st, codec);
648
        }
649

    
650
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
651
            nopts = 1;
652

    
653
        new_output_stream(s, nb_output_files);
654
    }
655

    
656
    if (!nopts)
657
        s->timestamp = av_gettime();
658

    
659
    av_close_input_file(ic);
660
    return 0;
661
}
662

    
663
static double
664
get_sync_ipts(const AVOutputStream *ost)
665
{
666
    const AVInputStream *ist = ost->sync_ist;
667
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
668
}
669

    
670
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
671
    int ret;
672

    
673
    while(bsfc){
674
        AVPacket new_pkt= *pkt;
675
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
676
                                          &new_pkt.data, &new_pkt.size,
677
                                          pkt->data, pkt->size,
678
                                          pkt->flags & AV_PKT_FLAG_KEY);
679
        if(a>0){
680
            av_free_packet(pkt);
681
            new_pkt.destruct= av_destruct_packet;
682
        } else if(a<0){
683
            fprintf(stderr, "%s failed for stream %d, codec %s",
684
                    bsfc->filter->name, pkt->stream_index,
685
                    avctx->codec ? avctx->codec->name : "copy");
686
            print_error("", a);
687
            if (exit_on_error)
688
                ffmpeg_exit(1);
689
        }
690
        *pkt= new_pkt;
691

    
692
        bsfc= bsfc->next;
693
    }
694

    
695
    ret= av_interleaved_write_frame(s, pkt);
696
    if(ret < 0){
697
        print_error("av_interleaved_write_frame()", ret);
698
        ffmpeg_exit(1);
699
    }
700
}
701

    
702
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
703

    
704
static void do_audio_out(AVFormatContext *s,
705
                         AVOutputStream *ost,
706
                         AVInputStream *ist,
707
                         unsigned char *buf, int size)
708
{
709
    uint8_t *buftmp;
710
    int64_t audio_out_size, audio_buf_size;
711
    int64_t allocated_for_size= size;
712

    
713
    int size_out, frame_bytes, ret, resample_changed;
714
    AVCodecContext *enc= ost->st->codec;
715
    AVCodecContext *dec= ist->st->codec;
716
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
717
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
718
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
719

    
720
need_realloc:
721
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
722
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
723
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
724
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
725
    audio_buf_size*= osize*enc->channels;
726

    
727
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
728
    if(coded_bps > 8*osize)
729
        audio_out_size= audio_out_size * coded_bps / (8*osize);
730
    audio_out_size += FF_MIN_BUFFER_SIZE;
731

    
732
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
733
        fprintf(stderr, "Buffer sizes too large\n");
734
        ffmpeg_exit(1);
735
    }
736

    
737
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
738
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
739
    if (!audio_buf || !audio_out){
740
        fprintf(stderr, "Out of memory in do_audio_out\n");
741
        ffmpeg_exit(1);
742
    }
743

    
744
    if (enc->channels != dec->channels)
745
        ost->audio_resample = 1;
746

    
747
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
748
                       ost->resample_channels    != dec->channels   ||
749
                       ost->resample_sample_rate != dec->sample_rate;
750

    
751
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
752
        if (resample_changed) {
753
            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",
754
                   ist->file_index, ist->index,
755
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
756
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
757
            ost->resample_sample_fmt  = dec->sample_fmt;
758
            ost->resample_channels    = dec->channels;
759
            ost->resample_sample_rate = dec->sample_rate;
760
            if (ost->resample)
761
                audio_resample_close(ost->resample);
762
        }
763
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
764
        if (audio_sync_method <= 1 &&
765
            ost->resample_sample_fmt  == enc->sample_fmt &&
766
            ost->resample_channels    == enc->channels   &&
767
            ost->resample_sample_rate == enc->sample_rate) {
768
            ost->resample = NULL;
769
            ost->audio_resample = 0;
770
        } else {
771
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
772
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
773
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
774
                                                   enc->sample_rate, dec->sample_rate,
775
                                                   enc->sample_fmt,  dec->sample_fmt,
776
                                                   16, 10, 0, 0.8);
777
            if (!ost->resample) {
778
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
779
                        dec->channels, dec->sample_rate,
780
                        enc->channels, enc->sample_rate);
781
                ffmpeg_exit(1);
782
            }
783
        }
784
    }
785

    
786
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
787
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
788
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
789
        if (ost->reformat_ctx)
790
            av_audio_convert_free(ost->reformat_ctx);
791
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
792
                                                   dec->sample_fmt, 1, NULL, 0);
793
        if (!ost->reformat_ctx) {
794
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
795
                av_get_sample_fmt_name(dec->sample_fmt),
796
                av_get_sample_fmt_name(enc->sample_fmt));
797
            ffmpeg_exit(1);
798
        }
799
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
800
    }
801

    
802
    if(audio_sync_method){
803
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
804
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
805
        double idelta= delta*dec->sample_rate / enc->sample_rate;
806
        int byte_delta= ((int)idelta)*2*dec->channels;
807

    
808
        //FIXME resample delay
809
        if(fabs(delta) > 50){
810
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
811
                if(byte_delta < 0){
812
                    byte_delta= FFMAX(byte_delta, -size);
813
                    size += byte_delta;
814
                    buf  -= byte_delta;
815
                    if(verbose > 2)
816
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
817
                    if(!size)
818
                        return;
819
                    ist->is_start=0;
820
                }else{
821
                    static uint8_t *input_tmp= NULL;
822
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
823

    
824
                    if(byte_delta > allocated_for_size - size){
825
                        allocated_for_size= byte_delta + (int64_t)size;
826
                        goto need_realloc;
827
                    }
828
                    ist->is_start=0;
829

    
830
                    memset(input_tmp, 0, byte_delta);
831
                    memcpy(input_tmp + byte_delta, buf, size);
832
                    buf= input_tmp;
833
                    size += byte_delta;
834
                    if(verbose > 2)
835
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
836
                }
837
            }else if(audio_sync_method>1){
838
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
839
                av_assert0(ost->audio_resample);
840
                if(verbose > 2)
841
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
842
//                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));
843
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
844
            }
845
        }
846
    }else
847
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
848
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
849

    
850
    if (ost->audio_resample) {
851
        buftmp = audio_buf;
852
        size_out = audio_resample(ost->resample,
853
                                  (short *)buftmp, (short *)buf,
854
                                  size / (dec->channels * isize));
855
        size_out = size_out * enc->channels * osize;
856
    } else {
857
        buftmp = buf;
858
        size_out = size;
859
    }
860

    
861
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
862
        const void *ibuf[6]= {buftmp};
863
        void *obuf[6]= {audio_buf};
864
        int istride[6]= {isize};
865
        int ostride[6]= {osize};
866
        int len= size_out/istride[0];
867
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
868
            printf("av_audio_convert() failed\n");
869
            if (exit_on_error)
870
                ffmpeg_exit(1);
871
            return;
872
        }
873
        buftmp = audio_buf;
874
        size_out = len*osize;
875
    }
876

    
877
    /* now encode as many frames as possible */
878
    if (enc->frame_size > 1) {
879
        /* output resampled raw samples */
880
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
881
            fprintf(stderr, "av_fifo_realloc2() failed\n");
882
            ffmpeg_exit(1);
883
        }
884
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
885

    
886
        frame_bytes = enc->frame_size * osize * enc->channels;
887

    
888
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
889
            AVPacket pkt;
890
            av_init_packet(&pkt);
891

    
892
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
893

    
894
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
895

    
896
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
897
                                       (short *)audio_buf);
898
            if (ret < 0) {
899
                fprintf(stderr, "Audio encoding failed\n");
900
                ffmpeg_exit(1);
901
            }
902
            audio_size += ret;
903
            pkt.stream_index= ost->index;
904
            pkt.data= audio_out;
905
            pkt.size= ret;
906
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
907
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
908
            pkt.flags |= AV_PKT_FLAG_KEY;
909
            write_frame(s, &pkt, enc, ost->bitstream_filters);
910

    
911
            ost->sync_opts += enc->frame_size;
912
        }
913
    } else {
914
        AVPacket pkt;
915
        av_init_packet(&pkt);
916

    
917
        ost->sync_opts += size_out / (osize * enc->channels);
918

    
919
        /* output a pcm frame */
920
        /* determine the size of the coded buffer */
921
        size_out /= osize;
922
        if (coded_bps)
923
            size_out = size_out*coded_bps/8;
924

    
925
        if(size_out > audio_out_size){
926
            fprintf(stderr, "Internal error, buffer size too small\n");
927
            ffmpeg_exit(1);
928
        }
929

    
930
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
931
        ret = avcodec_encode_audio(enc, audio_out, size_out,
932
                                   (short *)buftmp);
933
        if (ret < 0) {
934
            fprintf(stderr, "Audio encoding failed\n");
935
            ffmpeg_exit(1);
936
        }
937
        audio_size += ret;
938
        pkt.stream_index= ost->index;
939
        pkt.data= audio_out;
940
        pkt.size= ret;
941
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
942
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
943
        pkt.flags |= AV_PKT_FLAG_KEY;
944
        write_frame(s, &pkt, enc, ost->bitstream_filters);
945
    }
946
}
947

    
948
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
949
{
950
    AVCodecContext *dec;
951
    AVPicture *picture2;
952
    AVPicture picture_tmp;
953
    uint8_t *buf = 0;
954

    
955
    dec = ist->st->codec;
956

    
957
    /* deinterlace : must be done before any resize */
958
    if (do_deinterlace) {
959
        int size;
960

    
961
        /* create temporary picture */
962
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
963
        buf = av_malloc(size);
964
        if (!buf)
965
            return;
966

    
967
        picture2 = &picture_tmp;
968
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
969

    
970
        if(avpicture_deinterlace(picture2, picture,
971
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
972
            /* if error, do not deinterlace */
973
            fprintf(stderr, "Deinterlacing failed\n");
974
            av_free(buf);
975
            buf = NULL;
976
            picture2 = picture;
977
        }
978
    } else {
979
        picture2 = picture;
980
    }
981

    
982
    if (picture != picture2)
983
        *picture = *picture2;
984
    *bufp = buf;
985
}
986

    
987
/* we begin to correct av delay at this threshold */
988
#define AV_DELAY_MAX 0.100
989

    
990
static void do_subtitle_out(AVFormatContext *s,
991
                            AVOutputStream *ost,
992
                            AVInputStream *ist,
993
                            AVSubtitle *sub,
994
                            int64_t pts)
995
{
996
    static uint8_t *subtitle_out = NULL;
997
    int subtitle_out_max_size = 1024 * 1024;
998
    int subtitle_out_size, nb, i;
999
    AVCodecContext *enc;
1000
    AVPacket pkt;
1001

    
1002
    if (pts == AV_NOPTS_VALUE) {
1003
        fprintf(stderr, "Subtitle packets must have a pts\n");
1004
        if (exit_on_error)
1005
            ffmpeg_exit(1);
1006
        return;
1007
    }
1008

    
1009
    enc = ost->st->codec;
1010

    
1011
    if (!subtitle_out) {
1012
        subtitle_out = av_malloc(subtitle_out_max_size);
1013
    }
1014

    
1015
    /* Note: DVB subtitle need one packet to draw them and one other
1016
       packet to clear them */
1017
    /* XXX: signal it in the codec context ? */
1018
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1019
        nb = 2;
1020
    else
1021
        nb = 1;
1022

    
1023
    for(i = 0; i < nb; i++) {
1024
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1025
        // start_display_time is required to be 0
1026
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1027
        sub->end_display_time -= sub->start_display_time;
1028
        sub->start_display_time = 0;
1029
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1030
                                                    subtitle_out_max_size, sub);
1031
        if (subtitle_out_size < 0) {
1032
            fprintf(stderr, "Subtitle encoding failed\n");
1033
            ffmpeg_exit(1);
1034
        }
1035

    
1036
        av_init_packet(&pkt);
1037
        pkt.stream_index = ost->index;
1038
        pkt.data = subtitle_out;
1039
        pkt.size = subtitle_out_size;
1040
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1041
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1042
            /* XXX: the pts correction is handled here. Maybe handling
1043
               it in the codec would be better */
1044
            if (i == 0)
1045
                pkt.pts += 90 * sub->start_display_time;
1046
            else
1047
                pkt.pts += 90 * sub->end_display_time;
1048
        }
1049
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1050
    }
1051
}
1052

    
1053
static int bit_buffer_size= 1024*256;
1054
static uint8_t *bit_buffer= NULL;
1055

    
1056
static void do_video_out(AVFormatContext *s,
1057
                         AVOutputStream *ost,
1058
                         AVInputStream *ist,
1059
                         AVFrame *in_picture,
1060
                         int *frame_size)
1061
{
1062
    int nb_frames, i, ret;
1063
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1064
    AVCodecContext *enc, *dec;
1065
    double sync_ipts;
1066

    
1067
    enc = ost->st->codec;
1068
    dec = ist->st->codec;
1069

    
1070
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1071

    
1072
    /* by default, we output a single frame */
1073
    nb_frames = 1;
1074

    
1075
    *frame_size = 0;
1076

    
1077
    if(video_sync_method){
1078
        double vdelta = sync_ipts - ost->sync_opts;
1079
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1080
        if (vdelta < -1.1)
1081
            nb_frames = 0;
1082
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1083
            if(vdelta<=-0.6){
1084
                nb_frames=0;
1085
            }else if(vdelta>0.6)
1086
                ost->sync_opts= lrintf(sync_ipts);
1087
        }else if (vdelta > 1.1)
1088
            nb_frames = lrintf(vdelta);
1089
//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);
1090
        if (nb_frames == 0){
1091
            ++nb_frames_drop;
1092
            if (verbose>2)
1093
                fprintf(stderr, "*** drop!\n");
1094
        }else if (nb_frames > 1) {
1095
            nb_frames_dup += nb_frames - 1;
1096
            if (verbose>2)
1097
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1098
        }
1099
    }else
1100
        ost->sync_opts= lrintf(sync_ipts);
1101

    
1102
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1103
    if (nb_frames <= 0)
1104
        return;
1105

    
1106
    formatted_picture = in_picture;
1107
    final_picture = formatted_picture;
1108
    padding_src = formatted_picture;
1109
    resampling_dst = &ost->pict_tmp;
1110

    
1111
    if (   ost->resample_height != ist->st->codec->height
1112
        || ost->resample_width  != ist->st->codec->width
1113
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1114

    
1115
        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));
1116
        if(!ost->video_resample)
1117
            ffmpeg_exit(1);
1118
    }
1119

    
1120
#if !CONFIG_AVFILTER
1121
    if (ost->video_resample) {
1122
        padding_src = NULL;
1123
        final_picture = &ost->pict_tmp;
1124
        if(  ost->resample_height != ist->st->codec->height
1125
          || ost->resample_width  != ist->st->codec->width
1126
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1127

    
1128
            /* initialize a new scaler context */
1129
            sws_freeContext(ost->img_resample_ctx);
1130
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1131
            ost->img_resample_ctx = sws_getContext(
1132
                ist->st->codec->width,
1133
                ist->st->codec->height,
1134
                ist->st->codec->pix_fmt,
1135
                ost->st->codec->width,
1136
                ost->st->codec->height,
1137
                ost->st->codec->pix_fmt,
1138
                sws_flags, NULL, NULL, NULL);
1139
            if (ost->img_resample_ctx == NULL) {
1140
                fprintf(stderr, "Cannot get resampling context\n");
1141
                ffmpeg_exit(1);
1142
            }
1143
        }
1144
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1145
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1146
    }
1147
#endif
1148

    
1149
    /* duplicates frame if needed */
1150
    for(i=0;i<nb_frames;i++) {
1151
        AVPacket pkt;
1152
        av_init_packet(&pkt);
1153
        pkt.stream_index= ost->index;
1154

    
1155
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1156
            /* raw pictures are written as AVPicture structure to
1157
               avoid any copies. We support temorarily the older
1158
               method. */
1159
            AVFrame* old_frame = enc->coded_frame;
1160
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1161
            pkt.data= (uint8_t *)final_picture;
1162
            pkt.size=  sizeof(AVPicture);
1163
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1164
            pkt.flags |= AV_PKT_FLAG_KEY;
1165

    
1166
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1167
            enc->coded_frame = old_frame;
1168
        } else {
1169
            AVFrame big_picture;
1170

    
1171
            big_picture= *final_picture;
1172
            /* better than nothing: use input picture interlaced
1173
               settings */
1174
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1175
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1176
                if(top_field_first == -1)
1177
                    big_picture.top_field_first = in_picture->top_field_first;
1178
                else
1179
                    big_picture.top_field_first = top_field_first;
1180
            }
1181

    
1182
            /* handles sameq here. This is not correct because it may
1183
               not be a global option */
1184
            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1185
            if(!me_threshold)
1186
                big_picture.pict_type = 0;
1187
//            big_picture.pts = AV_NOPTS_VALUE;
1188
            big_picture.pts= ost->sync_opts;
1189
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1190
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1191
            if (ost->forced_kf_index < ost->forced_kf_count &&
1192
                big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1193
                big_picture.pict_type = FF_I_TYPE;
1194
                ost->forced_kf_index++;
1195
            }
1196
            ret = avcodec_encode_video(enc,
1197
                                       bit_buffer, bit_buffer_size,
1198
                                       &big_picture);
1199
            if (ret < 0) {
1200
                fprintf(stderr, "Video encoding failed\n");
1201
                ffmpeg_exit(1);
1202
            }
1203

    
1204
            if(ret>0){
1205
                pkt.data= bit_buffer;
1206
                pkt.size= ret;
1207
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1208
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1209
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1210
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1211
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1212

    
1213
                if(enc->coded_frame->key_frame)
1214
                    pkt.flags |= AV_PKT_FLAG_KEY;
1215
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1216
                *frame_size = ret;
1217
                video_size += ret;
1218
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1219
                //        enc->frame_number-1, ret, enc->pict_type);
1220
                /* if two pass, output log */
1221
                if (ost->logfile && enc->stats_out) {
1222
                    fprintf(ost->logfile, "%s", enc->stats_out);
1223
                }
1224
            }
1225
        }
1226
        ost->sync_opts++;
1227
        ost->frame_number++;
1228
    }
1229
}
1230

    
1231
static double psnr(double d){
1232
    return -10.0*log(d)/log(10.0);
1233
}
1234

    
1235
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1236
                           int frame_size)
1237
{
1238
    AVCodecContext *enc;
1239
    int frame_number;
1240
    double ti1, bitrate, avg_bitrate;
1241

    
1242
    /* this is executed just the first time do_video_stats is called */
1243
    if (!vstats_file) {
1244
        vstats_file = fopen(vstats_filename, "w");
1245
        if (!vstats_file) {
1246
            perror("fopen");
1247
            ffmpeg_exit(1);
1248
        }
1249
    }
1250

    
1251
    enc = ost->st->codec;
1252
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1253
        frame_number = ost->frame_number;
1254
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1255
        if (enc->flags&CODEC_FLAG_PSNR)
1256
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1257

    
1258
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1259
        /* compute pts value */
1260
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1261
        if (ti1 < 0.01)
1262
            ti1 = 0.01;
1263

    
1264
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1265
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1266
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1267
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1268
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1269
    }
1270
}
1271

    
1272
static void print_report(AVFormatContext **output_files,
1273
                         AVOutputStream **ost_table, int nb_ostreams,
1274
                         int is_last_report)
1275
{
1276
    char buf[1024];
1277
    AVOutputStream *ost;
1278
    AVFormatContext *oc;
1279
    int64_t total_size;
1280
    AVCodecContext *enc;
1281
    int frame_number, vid, i;
1282
    double bitrate, ti1, pts;
1283
    static int64_t last_time = -1;
1284
    static int qp_histogram[52];
1285

    
1286
    if (!is_last_report) {
1287
        int64_t cur_time;
1288
        /* display the report every 0.5 seconds */
1289
        cur_time = av_gettime();
1290
        if (last_time == -1) {
1291
            last_time = cur_time;
1292
            return;
1293
        }
1294
        if ((cur_time - last_time) < 500000)
1295
            return;
1296
        last_time = cur_time;
1297
    }
1298

    
1299

    
1300
    oc = output_files[0];
1301

    
1302
    total_size = avio_size(oc->pb);
1303
    if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1304
        total_size= avio_tell(oc->pb);
1305

    
1306
    buf[0] = '\0';
1307
    ti1 = 1e10;
1308
    vid = 0;
1309
    for(i=0;i<nb_ostreams;i++) {
1310
        ost = ost_table[i];
1311
        enc = ost->st->codec;
1312
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1313
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1314
                     !ost->st->stream_copy ?
1315
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1316
        }
1317
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1318
            float t = (av_gettime()-timer_start) / 1000000.0;
1319

    
1320
            frame_number = ost->frame_number;
1321
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1322
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1323
                     !ost->st->stream_copy ?
1324
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1325
            if(is_last_report)
1326
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1327
            if(qp_hist){
1328
                int j;
1329
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1330
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1331
                    qp_histogram[qp]++;
1332
                for(j=0; j<32; j++)
1333
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1334
            }
1335
            if (enc->flags&CODEC_FLAG_PSNR){
1336
                int j;
1337
                double error, error_sum=0;
1338
                double scale, scale_sum=0;
1339
                char type[3]= {'Y','U','V'};
1340
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1341
                for(j=0; j<3; j++){
1342
                    if(is_last_report){
1343
                        error= enc->error[j];
1344
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1345
                    }else{
1346
                        error= enc->coded_frame->error[j];
1347
                        scale= enc->width*enc->height*255.0*255.0;
1348
                    }
1349
                    if(j) scale/=4;
1350
                    error_sum += error;
1351
                    scale_sum += scale;
1352
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1353
                }
1354
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1355
            }
1356
            vid = 1;
1357
        }
1358
        /* compute min output value */
1359
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1360
        if ((pts < ti1) && (pts > 0))
1361
            ti1 = pts;
1362
    }
1363
    if (ti1 < 0.01)
1364
        ti1 = 0.01;
1365

    
1366
    if (verbose || is_last_report) {
1367
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1368

    
1369
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1370
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1371
            (double)total_size / 1024, ti1, bitrate);
1372

    
1373
        if (nb_frames_dup || nb_frames_drop)
1374
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1375
                  nb_frames_dup, nb_frames_drop);
1376

    
1377
        if (verbose >= 0)
1378
            fprintf(stderr, "%s    \r", buf);
1379

    
1380
        fflush(stderr);
1381
    }
1382

    
1383
    if (is_last_report && verbose >= 0){
1384
        int64_t raw= audio_size + video_size + extra_size;
1385
        fprintf(stderr, "\n");
1386
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1387
                video_size/1024.0,
1388
                audio_size/1024.0,
1389
                extra_size/1024.0,
1390
                100.0*(total_size - raw)/raw
1391
        );
1392
    }
1393
}
1394

    
1395
static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1396
{
1397
    int fill_char = 0x00;
1398
    if (sample_fmt == AV_SAMPLE_FMT_U8)
1399
        fill_char = 0x80;
1400
    memset(buf, fill_char, size);
1401
}
1402

    
1403
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1404
static int output_packet(AVInputStream *ist, int ist_index,
1405
                         AVOutputStream **ost_table, int nb_ostreams,
1406
                         const AVPacket *pkt)
1407
{
1408
    AVFormatContext *os;
1409
    AVOutputStream *ost;
1410
    int ret, i;
1411
    int got_picture;
1412
    AVFrame picture;
1413
    void *buffer_to_free;
1414
    static unsigned int samples_size= 0;
1415
    AVSubtitle subtitle, *subtitle_to_free;
1416
    int64_t pkt_pts = AV_NOPTS_VALUE;
1417
#if CONFIG_AVFILTER
1418
    int frame_available;
1419
#endif
1420

    
1421
    AVPacket avpkt;
1422
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1423

    
1424
    if(ist->next_pts == AV_NOPTS_VALUE)
1425
        ist->next_pts= ist->pts;
1426

    
1427
    if (pkt == NULL) {
1428
        /* EOF handling */
1429
        av_init_packet(&avpkt);
1430
        avpkt.data = NULL;
1431
        avpkt.size = 0;
1432
        goto handle_eof;
1433
    } else {
1434
        avpkt = *pkt;
1435
    }
1436

    
1437
    if(pkt->dts != AV_NOPTS_VALUE)
1438
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1439
    if(pkt->pts != AV_NOPTS_VALUE)
1440
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1441

    
1442
    //while we have more to decode or while the decoder did output something on EOF
1443
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1444
        uint8_t *data_buf, *decoded_data_buf;
1445
        int data_size, decoded_data_size;
1446
    handle_eof:
1447
        ist->pts= ist->next_pts;
1448

    
1449
        if(avpkt.size && avpkt.size != pkt->size &&
1450
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1451
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1452
            ist->showed_multi_packet_warning=1;
1453
        }
1454

    
1455
        /* decode the packet if needed */
1456
        decoded_data_buf = NULL; /* fail safe */
1457
        decoded_data_size= 0;
1458
        data_buf  = avpkt.data;
1459
        data_size = avpkt.size;
1460
        subtitle_to_free = NULL;
1461
        if (ist->decoding_needed) {
1462
            switch(ist->st->codec->codec_type) {
1463
            case AVMEDIA_TYPE_AUDIO:{
1464
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1465
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1466
                    av_free(samples);
1467
                    samples= av_malloc(samples_size);
1468
                }
1469
                decoded_data_size= samples_size;
1470
                    /* XXX: could avoid copy if PCM 16 bits with same
1471
                       endianness as CPU */
1472
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1473
                                            &avpkt);
1474
                if (ret < 0)
1475
                    goto fail_decode;
1476
                avpkt.data += ret;
1477
                avpkt.size -= ret;
1478
                data_size   = ret;
1479
                /* Some bug in mpeg audio decoder gives */
1480
                /* decoded_data_size < 0, it seems they are overflows */
1481
                if (decoded_data_size <= 0) {
1482
                    /* no audio frame */
1483
                    continue;
1484
                }
1485
                decoded_data_buf = (uint8_t *)samples;
1486
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1487
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1488
                break;}
1489
            case AVMEDIA_TYPE_VIDEO:
1490
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1491
                    /* XXX: allocate picture correctly */
1492
                    avcodec_get_frame_defaults(&picture);
1493
                    avpkt.pts = pkt_pts;
1494
                    avpkt.dts = ist->pts;
1495
                    pkt_pts = AV_NOPTS_VALUE;
1496

    
1497
                    ret = avcodec_decode_video2(ist->st->codec,
1498
                                                &picture, &got_picture, &avpkt);
1499
                    ist->st->quality= picture.quality;
1500
                    if (ret < 0)
1501
                        goto fail_decode;
1502
                    if (!got_picture) {
1503
                        /* no picture yet */
1504
                        goto discard_packet;
1505
                    }
1506
                    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1507
                    if (ist->st->codec->time_base.num != 0) {
1508
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1509
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1510
                                          ist->st->codec->time_base.num * ticks) /
1511
                            ist->st->codec->time_base.den;
1512
                    }
1513
                    avpkt.size = 0;
1514
                    break;
1515
            case AVMEDIA_TYPE_SUBTITLE:
1516
                ret = avcodec_decode_subtitle2(ist->st->codec,
1517
                                               &subtitle, &got_picture, &avpkt);
1518
                if (ret < 0)
1519
                    goto fail_decode;
1520
                if (!got_picture) {
1521
                    goto discard_packet;
1522
                }
1523
                subtitle_to_free = &subtitle;
1524
                avpkt.size = 0;
1525
                break;
1526
            default:
1527
                goto fail_decode;
1528
            }
1529
        } else {
1530
            switch(ist->st->codec->codec_type) {
1531
            case AVMEDIA_TYPE_AUDIO:
1532
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1533
                    ist->st->codec->sample_rate;
1534
                break;
1535
            case AVMEDIA_TYPE_VIDEO:
1536
                if (ist->st->codec->time_base.num != 0) {
1537
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1538
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1539
                                      ist->st->codec->time_base.num * ticks) /
1540
                        ist->st->codec->time_base.den;
1541
                }
1542
                break;
1543
            }
1544
            ret = avpkt.size;
1545
            avpkt.size = 0;
1546
        }
1547

    
1548
        buffer_to_free = NULL;
1549
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1550
            pre_process_video_frame(ist, (AVPicture *)&picture,
1551
                                    &buffer_to_free);
1552
        }
1553

    
1554
#if CONFIG_AVFILTER
1555
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1556
            AVRational sar;
1557
            if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1558
            else                                  sar = ist->st->codec->sample_aspect_ratio;
1559
            // add it to be filtered
1560
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1561
                                     ist->pts,
1562
                                     sar);
1563
        }
1564
#endif
1565

    
1566
        // preprocess audio (volume)
1567
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1568
            if (audio_volume != 256) {
1569
                short *volp;
1570
                volp = samples;
1571
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1572
                    int v = ((*volp) * audio_volume + 128) >> 8;
1573
                    if (v < -32768) v = -32768;
1574
                    if (v >  32767) v = 32767;
1575
                    *volp++ = v;
1576
                }
1577
            }
1578
        }
1579

    
1580
        /* frame rate emulation */
1581
        if (rate_emu) {
1582
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1583
            int64_t now = av_gettime() - ist->start;
1584
            if (pts > now)
1585
                usleep(pts - now);
1586
        }
1587
#if CONFIG_AVFILTER
1588
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1589
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1590
#endif
1591
        /* if output time reached then transcode raw format,
1592
           encode packets and output them */
1593
        if (start_time == 0 || ist->pts >= start_time)
1594
#if CONFIG_AVFILTER
1595
        while (frame_available) {
1596
            AVRational ist_pts_tb;
1597
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1598
                get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1599
            if (ist->picref)
1600
                ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1601
#endif
1602
            for(i=0;i<nb_ostreams;i++) {
1603
                int frame_size;
1604

    
1605
                ost = ost_table[i];
1606
                if (ost->source_index == ist_index) {
1607
                    os = output_files[ost->file_index];
1608

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

    
1612
                    if (ost->encoding_needed) {
1613
                        av_assert0(ist->decoding_needed);
1614
                        switch(ost->st->codec->codec_type) {
1615
                        case AVMEDIA_TYPE_AUDIO:
1616
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1617
                            break;
1618
                        case AVMEDIA_TYPE_VIDEO:
1619
#if CONFIG_AVFILTER
1620
                            if (ist->picref->video)
1621
                                ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1622
#endif
1623
                            do_video_out(os, ost, ist, &picture, &frame_size);
1624
                            if (vstats_filename && frame_size)
1625
                                do_video_stats(os, ost, frame_size);
1626
                            break;
1627
                        case AVMEDIA_TYPE_SUBTITLE:
1628
                            do_subtitle_out(os, ost, ist, &subtitle,
1629
                                            pkt->pts);
1630
                            break;
1631
                        default:
1632
                            abort();
1633
                        }
1634
                    } else {
1635
                        AVFrame avframe; //FIXME/XXX remove this
1636
                        AVPacket opkt;
1637
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1638

    
1639
                        av_init_packet(&opkt);
1640

    
1641
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1642
                            continue;
1643

    
1644
                        /* no reencoding needed : output the packet directly */
1645
                        /* force the input stream PTS */
1646

    
1647
                        avcodec_get_frame_defaults(&avframe);
1648
                        ost->st->codec->coded_frame= &avframe;
1649
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1650

    
1651
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1652
                            audio_size += data_size;
1653
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1654
                            video_size += data_size;
1655
                            ost->sync_opts++;
1656
                        }
1657

    
1658
                        opkt.stream_index= ost->index;
1659
                        if(pkt->pts != AV_NOPTS_VALUE)
1660
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1661
                        else
1662
                            opkt.pts= AV_NOPTS_VALUE;
1663

    
1664
                        if (pkt->dts == AV_NOPTS_VALUE)
1665
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1666
                        else
1667
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1668
                        opkt.dts -= ost_tb_start_time;
1669

    
1670
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1671
                        opkt.flags= pkt->flags;
1672

    
1673
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1674
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1675
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1676
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1677
                           ) {
1678
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1679
                                opkt.destruct= av_destruct_packet;
1680
                        } else {
1681
                            opkt.data = data_buf;
1682
                            opkt.size = data_size;
1683
                        }
1684

    
1685
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1686
                        ost->st->codec->frame_number++;
1687
                        ost->frame_number++;
1688
                        av_free_packet(&opkt);
1689
                    }
1690
                }
1691
            }
1692

    
1693
#if CONFIG_AVFILTER
1694
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1695
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1696
            if(ist->picref)
1697
                avfilter_unref_buffer(ist->picref);
1698
        }
1699
#endif
1700
        av_free(buffer_to_free);
1701
        /* XXX: allocate the subtitles in the codec ? */
1702
        if (subtitle_to_free) {
1703
            avsubtitle_free(subtitle_to_free);
1704
            subtitle_to_free = NULL;
1705
        }
1706
    }
1707
 discard_packet:
1708
    if (pkt == NULL) {
1709
        /* EOF handling */
1710

    
1711
        for(i=0;i<nb_ostreams;i++) {
1712
            ost = ost_table[i];
1713
            if (ost->source_index == ist_index) {
1714
                AVCodecContext *enc= ost->st->codec;
1715
                os = output_files[ost->file_index];
1716

    
1717
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1718
                    continue;
1719
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1720
                    continue;
1721

    
1722
                if (ost->encoding_needed) {
1723
                    for(;;) {
1724
                        AVPacket pkt;
1725
                        int fifo_bytes;
1726
                        av_init_packet(&pkt);
1727
                        pkt.stream_index= ost->index;
1728

    
1729
                        switch(ost->st->codec->codec_type) {
1730
                        case AVMEDIA_TYPE_AUDIO:
1731
                            fifo_bytes = av_fifo_size(ost->fifo);
1732
                            ret = 0;
1733
                            /* encode any samples remaining in fifo */
1734
                            if (fifo_bytes > 0) {
1735
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1736
                                int fs_tmp = enc->frame_size;
1737

    
1738
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1739
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1740
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1741
                                } else { /* pad */
1742
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1743
                                    if (allocated_audio_buf_size < frame_bytes)
1744
                                        ffmpeg_exit(1);
1745
                                    generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1746
                                }
1747

    
1748
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1749
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1750
                                                          ost->st->time_base.num, enc->sample_rate);
1751
                                enc->frame_size = fs_tmp;
1752
                            }
1753
                            if(ret <= 0) {
1754
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1755
                            }
1756
                            if (ret < 0) {
1757
                                fprintf(stderr, "Audio encoding failed\n");
1758
                                ffmpeg_exit(1);
1759
                            }
1760
                            audio_size += ret;
1761
                            pkt.flags |= AV_PKT_FLAG_KEY;
1762
                            break;
1763
                        case AVMEDIA_TYPE_VIDEO:
1764
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1765
                            if (ret < 0) {
1766
                                fprintf(stderr, "Video encoding failed\n");
1767
                                ffmpeg_exit(1);
1768
                            }
1769
                            video_size += ret;
1770
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1771
                                pkt.flags |= AV_PKT_FLAG_KEY;
1772
                            if (ost->logfile && enc->stats_out) {
1773
                                fprintf(ost->logfile, "%s", enc->stats_out);
1774
                            }
1775
                            break;
1776
                        default:
1777
                            ret=-1;
1778
                        }
1779

    
1780
                        if(ret<=0)
1781
                            break;
1782
                        pkt.data= bit_buffer;
1783
                        pkt.size= ret;
1784
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1785
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1786
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1787
                    }
1788
                }
1789
            }
1790
        }
1791
    }
1792

    
1793
    return 0;
1794
 fail_decode:
1795
    return -1;
1796
}
1797

    
1798
static void print_sdp(AVFormatContext **avc, int n)
1799
{
1800
    char sdp[2048];
1801

    
1802
    av_sdp_create(avc, n, sdp, sizeof(sdp));
1803
    printf("SDP:\n%s\n", sdp);
1804
    fflush(stdout);
1805
}
1806

    
1807
static int copy_chapters(int infile, int outfile)
1808
{
1809
    AVFormatContext *is = input_files[infile];
1810
    AVFormatContext *os = output_files[outfile];
1811
    int i;
1812

    
1813
    for (i = 0; i < is->nb_chapters; i++) {
1814
        AVChapter *in_ch = is->chapters[i], *out_ch;
1815
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1816
                                      AV_TIME_BASE_Q, in_ch->time_base);
1817
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1818
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1819

    
1820

    
1821
        if (in_ch->end < ts_off)
1822
            continue;
1823
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1824
            break;
1825

    
1826
        out_ch = av_mallocz(sizeof(AVChapter));
1827
        if (!out_ch)
1828
            return AVERROR(ENOMEM);
1829

    
1830
        out_ch->id        = in_ch->id;
1831
        out_ch->time_base = in_ch->time_base;
1832
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1833
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1834

    
1835
        if (metadata_chapters_autocopy)
1836
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1837

    
1838
        os->nb_chapters++;
1839
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1840
        if (!os->chapters)
1841
            return AVERROR(ENOMEM);
1842
        os->chapters[os->nb_chapters - 1] = out_ch;
1843
    }
1844
    return 0;
1845
}
1846

    
1847
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1848
                                    AVCodecContext *avctx)
1849
{
1850
    char *p;
1851
    int n = 1, i;
1852
    int64_t t;
1853

    
1854
    for (p = kf; *p; p++)
1855
        if (*p == ',')
1856
            n++;
1857
    ost->forced_kf_count = n;
1858
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1859
    if (!ost->forced_kf_pts) {
1860
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1861
        ffmpeg_exit(1);
1862
    }
1863
    for (i = 0; i < n; i++) {
1864
        p = i ? strchr(p, ',') + 1 : kf;
1865
        t = parse_time_or_die("force_key_frames", p, 1);
1866
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1867
    }
1868
}
1869

    
1870
/*
1871
 * The following code is the main loop of the file converter
1872
 */
1873
static int transcode(AVFormatContext **output_files,
1874
                     int nb_output_files,
1875
                     AVFormatContext **input_files,
1876
                     int nb_input_files,
1877
                     AVStreamMap *stream_maps, int nb_stream_maps)
1878
{
1879
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1880
    AVFormatContext *is, *os;
1881
    AVCodecContext *codec, *icodec;
1882
    AVOutputStream *ost, **ost_table = NULL;
1883
    AVInputStream *ist, **ist_table = NULL;
1884
    AVInputFile *file_table;
1885
    char error[1024];
1886
    int key;
1887
    int want_sdp = 1;
1888
    uint8_t no_packet[MAX_FILES]={0};
1889
    int no_packet_count=0;
1890

    
1891
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1892
    if (!file_table)
1893
        goto fail;
1894

    
1895
    /* input stream init */
1896
    j = 0;
1897
    for(i=0;i<nb_input_files;i++) {
1898
        is = input_files[i];
1899
        file_table[i].ist_index = j;
1900
        file_table[i].nb_streams = is->nb_streams;
1901
        j += is->nb_streams;
1902
    }
1903
    nb_istreams = j;
1904

    
1905
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1906
    if (!ist_table)
1907
        goto fail;
1908

    
1909
    for(i=0;i<nb_istreams;i++) {
1910
        ist = av_mallocz(sizeof(AVInputStream));
1911
        if (!ist)
1912
            goto fail;
1913
        ist_table[i] = ist;
1914
    }
1915
    j = 0;
1916
    for(i=0;i<nb_input_files;i++) {
1917
        is = input_files[i];
1918
        for(k=0;k<is->nb_streams;k++) {
1919
            ist = ist_table[j++];
1920
            ist->st = is->streams[k];
1921
            ist->file_index = i;
1922
            ist->index = k;
1923
            ist->discard = 1; /* the stream is discarded by default
1924
                                 (changed later) */
1925

    
1926
            if (rate_emu) {
1927
                ist->start = av_gettime();
1928
            }
1929
        }
1930
    }
1931

    
1932
    /* output stream init */
1933
    nb_ostreams = 0;
1934
    for(i=0;i<nb_output_files;i++) {
1935
        os = output_files[i];
1936
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1937
            av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1938
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1939
            ret = AVERROR(EINVAL);
1940
            goto fail;
1941
        }
1942
        nb_ostreams += os->nb_streams;
1943
    }
1944
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1945
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1946
        ret = AVERROR(EINVAL);
1947
        goto fail;
1948
    }
1949

    
1950
    /* Sanity check the mapping args -- do the input files & streams exist? */
1951
    for(i=0;i<nb_stream_maps;i++) {
1952
        int fi = stream_maps[i].file_index;
1953
        int si = stream_maps[i].stream_index;
1954

    
1955
        if (fi < 0 || fi > nb_input_files - 1 ||
1956
            si < 0 || si > file_table[fi].nb_streams - 1) {
1957
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1958
            ret = AVERROR(EINVAL);
1959
            goto fail;
1960
        }
1961
        fi = stream_maps[i].sync_file_index;
1962
        si = stream_maps[i].sync_stream_index;
1963
        if (fi < 0 || fi > nb_input_files - 1 ||
1964
            si < 0 || si > file_table[fi].nb_streams - 1) {
1965
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1966
            ret = AVERROR(EINVAL);
1967
            goto fail;
1968
        }
1969
    }
1970

    
1971
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1972
    if (!ost_table)
1973
        goto fail;
1974
    n = 0;
1975
    for(k=0;k<nb_output_files;k++) {
1976
        os = output_files[k];
1977
        for(i=0;i<os->nb_streams;i++,n++) {
1978
            int found;
1979
            ost = ost_table[n] = output_streams_for_file[k][i];
1980
            ost->st = os->streams[i];
1981
            if (nb_stream_maps > 0) {
1982
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1983
                    stream_maps[n].stream_index;
1984

    
1985
                /* Sanity check that the stream types match */
1986
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1987
                    int i= ost->file_index;
1988
                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1989
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1990
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1991
                        ost->file_index, ost->index);
1992
                    ffmpeg_exit(1);
1993
                }
1994

    
1995
            } else {
1996
                int best_nb_frames=-1;
1997
                /* get corresponding input stream index : we select the first one with the right type */
1998
                found = 0;
1999
                for(j=0;j<nb_istreams;j++) {
2000
                    int skip=0;
2001
                    ist = ist_table[j];
2002
                    if(opt_programid){
2003
                        int pi,si;
2004
                        AVFormatContext *f= input_files[ ist->file_index ];
2005
                        skip=1;
2006
                        for(pi=0; pi<f->nb_programs; pi++){
2007
                            AVProgram *p= f->programs[pi];
2008
                            if(p->id == opt_programid)
2009
                                for(si=0; si<p->nb_stream_indexes; si++){
2010
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2011
                                        skip=0;
2012
                                }
2013
                        }
2014
                    }
2015
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2016
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2017
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2018
                            best_nb_frames= ist->st->codec_info_nb_frames;
2019
                            ost->source_index = j;
2020
                            found = 1;
2021
                        }
2022
                    }
2023
                }
2024

    
2025
                if (!found) {
2026
                    if(! opt_programid) {
2027
                        /* try again and reuse existing stream */
2028
                        for(j=0;j<nb_istreams;j++) {
2029
                            ist = ist_table[j];
2030
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2031
                                && ist->st->discard != AVDISCARD_ALL) {
2032
                                ost->source_index = j;
2033
                                found = 1;
2034
                            }
2035
                        }
2036
                    }
2037
                    if (!found) {
2038
                        int i= ost->file_index;
2039
                        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2040
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2041
                                ost->file_index, ost->index);
2042
                        ffmpeg_exit(1);
2043
                    }
2044
                }
2045
            }
2046
            ist = ist_table[ost->source_index];
2047
            ist->discard = 0;
2048
            ost->sync_ist = (nb_stream_maps > 0) ?
2049
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2050
                         stream_maps[n].sync_stream_index] : ist;
2051
        }
2052
    }
2053

    
2054
    /* for each output stream, we compute the right encoding parameters */
2055
    for(i=0;i<nb_ostreams;i++) {
2056
        ost = ost_table[i];
2057
        os = output_files[ost->file_index];
2058
        ist = ist_table[ost->source_index];
2059

    
2060
        codec = ost->st->codec;
2061
        icodec = ist->st->codec;
2062

    
2063
        if (metadata_streams_autocopy)
2064
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2065
                             AV_METADATA_DONT_OVERWRITE);
2066

    
2067
        ost->st->disposition = ist->st->disposition;
2068
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2069
        codec->chroma_sample_location = icodec->chroma_sample_location;
2070

    
2071
        if (ost->st->stream_copy) {
2072
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2073

    
2074
            if (extra_size > INT_MAX)
2075
                goto fail;
2076

    
2077
            /* if stream_copy is selected, no need to decode or encode */
2078
            codec->codec_id = icodec->codec_id;
2079
            codec->codec_type = icodec->codec_type;
2080

    
2081
            if(!codec->codec_tag){
2082
                if(   !os->oformat->codec_tag
2083
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2084
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2085
                    codec->codec_tag = icodec->codec_tag;
2086
            }
2087

    
2088
            codec->bit_rate = icodec->bit_rate;
2089
            codec->rc_max_rate    = icodec->rc_max_rate;
2090
            codec->rc_buffer_size = icodec->rc_buffer_size;
2091
            codec->extradata= av_mallocz(extra_size);
2092
            if (!codec->extradata)
2093
                goto fail;
2094
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2095
            codec->extradata_size= icodec->extradata_size;
2096
            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){
2097
                codec->time_base = icodec->time_base;
2098
                codec->time_base.num *= icodec->ticks_per_frame;
2099
                av_reduce(&codec->time_base.num, &codec->time_base.den,
2100
                          codec->time_base.num, codec->time_base.den, INT_MAX);
2101
            }else
2102
                codec->time_base = ist->st->time_base;
2103
            switch(codec->codec_type) {
2104
            case AVMEDIA_TYPE_AUDIO:
2105
                if(audio_volume != 256) {
2106
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2107
                    ffmpeg_exit(1);
2108
                }
2109
                codec->channel_layout = icodec->channel_layout;
2110
                codec->sample_rate = icodec->sample_rate;
2111
                codec->channels = icodec->channels;
2112
                codec->frame_size = icodec->frame_size;
2113
                codec->audio_service_type = icodec->audio_service_type;
2114
                codec->block_align= icodec->block_align;
2115
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2116
                    codec->block_align= 0;
2117
                if(codec->codec_id == CODEC_ID_AC3)
2118
                    codec->block_align= 0;
2119
                break;
2120
            case AVMEDIA_TYPE_VIDEO:
2121
                codec->pix_fmt = icodec->pix_fmt;
2122
                codec->width = icodec->width;
2123
                codec->height = icodec->height;
2124
                codec->has_b_frames = icodec->has_b_frames;
2125
                break;
2126
            case AVMEDIA_TYPE_SUBTITLE:
2127
                codec->width = icodec->width;
2128
                codec->height = icodec->height;
2129
                break;
2130
            default:
2131
                abort();
2132
            }
2133
        } else {
2134
            switch(codec->codec_type) {
2135
            case AVMEDIA_TYPE_AUDIO:
2136
                ost->fifo= av_fifo_alloc(1024);
2137
                if(!ost->fifo)
2138
                    goto fail;
2139
                ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2140
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2141
                icodec->request_channels = codec->channels;
2142
                ist->decoding_needed = 1;
2143
                ost->encoding_needed = 1;
2144
                ost->resample_sample_fmt  = icodec->sample_fmt;
2145
                ost->resample_sample_rate = icodec->sample_rate;
2146
                ost->resample_channels    = icodec->channels;
2147
                break;
2148
            case AVMEDIA_TYPE_VIDEO:
2149
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2150
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2151
                    ffmpeg_exit(1);
2152
                }
2153
                ost->video_resample = (codec->width != icodec->width   ||
2154
                                       codec->height != icodec->height ||
2155
                        (codec->pix_fmt != icodec->pix_fmt));
2156
                if (ost->video_resample) {
2157
#if !CONFIG_AVFILTER
2158
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2159
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2160
                                         codec->width, codec->height)) {
2161
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2162
                        ffmpeg_exit(1);
2163
                    }
2164
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2165
                    ost->img_resample_ctx = sws_getContext(
2166
                        icodec->width,
2167
                        icodec->height,
2168
                            icodec->pix_fmt,
2169
                            codec->width,
2170
                            codec->height,
2171
                            codec->pix_fmt,
2172
                            sws_flags, NULL, NULL, NULL);
2173
                    if (ost->img_resample_ctx == NULL) {
2174
                        fprintf(stderr, "Cannot get resampling context\n");
2175
                        ffmpeg_exit(1);
2176
                    }
2177

    
2178
                    ost->original_height = icodec->height;
2179
                    ost->original_width  = icodec->width;
2180
#endif
2181
                    codec->bits_per_raw_sample= 0;
2182
                }
2183
                ost->resample_height = icodec->height;
2184
                ost->resample_width  = icodec->width;
2185
                ost->resample_pix_fmt= icodec->pix_fmt;
2186
                ost->encoding_needed = 1;
2187
                ist->decoding_needed = 1;
2188

    
2189
#if CONFIG_AVFILTER
2190
                if (configure_filters(ist, ost)) {
2191
                    fprintf(stderr, "Error opening filters!\n");
2192
                    exit(1);
2193
                }
2194
#endif
2195
                break;
2196
            case AVMEDIA_TYPE_SUBTITLE:
2197
                ost->encoding_needed = 1;
2198
                ist->decoding_needed = 1;
2199
                break;
2200
            default:
2201
                abort();
2202
                break;
2203
            }
2204
            /* two pass mode */
2205
            if (ost->encoding_needed &&
2206
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2207
                char logfilename[1024];
2208
                FILE *f;
2209

    
2210
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2211
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2212
                         i);
2213
                if (codec->flags & CODEC_FLAG_PASS1) {
2214
                    f = fopen(logfilename, "wb");
2215
                    if (!f) {
2216
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2217
                        ffmpeg_exit(1);
2218
                    }
2219
                    ost->logfile = f;
2220
                } else {
2221
                    char  *logbuffer;
2222
                    size_t logbuffer_size;
2223
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2224
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2225
                        ffmpeg_exit(1);
2226
                    }
2227
                    codec->stats_in = logbuffer;
2228
                }
2229
            }
2230
        }
2231
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2232
            int size= codec->width * codec->height;
2233
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2234
        }
2235
    }
2236

    
2237
    if (!bit_buffer)
2238
        bit_buffer = av_malloc(bit_buffer_size);
2239
    if (!bit_buffer) {
2240
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2241
                bit_buffer_size);
2242
        ret = AVERROR(ENOMEM);
2243
        goto fail;
2244
    }
2245

    
2246
    /* open each encoder */
2247
    for(i=0;i<nb_ostreams;i++) {
2248
        ost = ost_table[i];
2249
        if (ost->encoding_needed) {
2250
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2251
            AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2252
            if (!codec)
2253
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2254
            if (!codec) {
2255
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2256
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2257
                ret = AVERROR(EINVAL);
2258
                goto dump_format;
2259
            }
2260
            if (dec->subtitle_header) {
2261
                ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2262
                if (!ost->st->codec->subtitle_header) {
2263
                    ret = AVERROR(ENOMEM);
2264
                    goto dump_format;
2265
                }
2266
                memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2267
                ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2268
            }
2269
            if (avcodec_open(ost->st->codec, codec) < 0) {
2270
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2271
                        ost->file_index, ost->index);
2272
                ret = AVERROR(EINVAL);
2273
                goto dump_format;
2274
            }
2275
            extra_size += ost->st->codec->extradata_size;
2276
        }
2277
    }
2278

    
2279
    /* open each decoder */
2280
    for(i=0;i<nb_istreams;i++) {
2281
        ist = ist_table[i];
2282
        if (ist->decoding_needed) {
2283
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2284
            if (!codec)
2285
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2286
            if (!codec) {
2287
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2288
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2289
                ret = AVERROR(EINVAL);
2290
                goto dump_format;
2291
            }
2292
            if (avcodec_open(ist->st->codec, codec) < 0) {
2293
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2294
                        ist->file_index, ist->index);
2295
                ret = AVERROR(EINVAL);
2296
                goto dump_format;
2297
            }
2298
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2299
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2300
        }
2301
    }
2302

    
2303
    /* init pts */
2304
    for(i=0;i<nb_istreams;i++) {
2305
        AVStream *st;
2306
        ist = ist_table[i];
2307
        st= ist->st;
2308
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2309
        ist->next_pts = AV_NOPTS_VALUE;
2310
        init_pts_correction(&ist->pts_ctx);
2311
        ist->is_start = 1;
2312
    }
2313

    
2314
    /* set meta data information from input file if required */
2315
    for (i=0;i<nb_meta_data_maps;i++) {
2316
        AVFormatContext *files[2];
2317
        AVMetadata      **meta[2];
2318
        int j;
2319

    
2320
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2321
        if ((index) < 0 || (index) >= (nb_elems)) {\
2322
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2323
                     (desc), (index));\
2324
            ret = AVERROR(EINVAL);\
2325
            goto dump_format;\
2326
        }
2327

    
2328
        int out_file_index = meta_data_maps[i][0].file;
2329
        int in_file_index = meta_data_maps[i][1].file;
2330
        if (in_file_index < 0 || out_file_index < 0)
2331
            continue;
2332
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2333
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2334

    
2335
        files[0] = output_files[out_file_index];
2336
        files[1] = input_files[in_file_index];
2337

    
2338
        for (j = 0; j < 2; j++) {
2339
            AVMetaDataMap *map = &meta_data_maps[i][j];
2340

    
2341
            switch (map->type) {
2342
            case 'g':
2343
                meta[j] = &files[j]->metadata;
2344
                break;
2345
            case 's':
2346
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2347
                meta[j] = &files[j]->streams[map->index]->metadata;
2348
                break;
2349
            case 'c':
2350
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2351
                meta[j] = &files[j]->chapters[map->index]->metadata;
2352
                break;
2353
            case 'p':
2354
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2355
                meta[j] = &files[j]->programs[map->index]->metadata;
2356
                break;
2357
            }
2358
        }
2359

    
2360
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2361
    }
2362

    
2363
    /* copy global metadata by default */
2364
    if (metadata_global_autocopy) {
2365

    
2366
        for (i = 0; i < nb_output_files; i++)
2367
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2368
                             AV_METADATA_DONT_OVERWRITE);
2369
    }
2370

    
2371
    /* copy chapters according to chapter maps */
2372
    for (i = 0; i < nb_chapter_maps; i++) {
2373
        int infile  = chapter_maps[i].in_file;
2374
        int outfile = chapter_maps[i].out_file;
2375

    
2376
        if (infile < 0 || outfile < 0)
2377
            continue;
2378
        if (infile >= nb_input_files) {
2379
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2380
            ret = AVERROR(EINVAL);
2381
            goto dump_format;
2382
        }
2383
        if (outfile >= nb_output_files) {
2384
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2385
            ret = AVERROR(EINVAL);
2386
            goto dump_format;
2387
        }
2388
        copy_chapters(infile, outfile);
2389
    }
2390

    
2391
    /* copy chapters from the first input file that has them*/
2392
    if (!nb_chapter_maps)
2393
        for (i = 0; i < nb_input_files; i++) {
2394
            if (!input_files[i]->nb_chapters)
2395
                continue;
2396

    
2397
            for (j = 0; j < nb_output_files; j++)
2398
                if ((ret = copy_chapters(i, j)) < 0)
2399
                    goto dump_format;
2400
            break;
2401
        }
2402

    
2403
    /* open files and write file headers */
2404
    for(i=0;i<nb_output_files;i++) {
2405
        os = output_files[i];
2406
        if (av_write_header(os) < 0) {
2407
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2408
            ret = AVERROR(EINVAL);
2409
            goto dump_format;
2410
        }
2411
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2412
            want_sdp = 0;
2413
        }
2414
    }
2415

    
2416
 dump_format:
2417
    /* dump the file output parameters - cannot be done before in case
2418
       of stream copy */
2419
    for(i=0;i<nb_output_files;i++) {
2420
        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2421
    }
2422

    
2423
    /* dump the stream mapping */
2424
    if (verbose >= 0) {
2425
        fprintf(stderr, "Stream mapping:\n");
2426
        for(i=0;i<nb_ostreams;i++) {
2427
            ost = ost_table[i];
2428
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2429
                    ist_table[ost->source_index]->file_index,
2430
                    ist_table[ost->source_index]->index,
2431
                    ost->file_index,
2432
                    ost->index);
2433
            if (ost->sync_ist != ist_table[ost->source_index])
2434
                fprintf(stderr, " [sync #%d.%d]",
2435
                        ost->sync_ist->file_index,
2436
                        ost->sync_ist->index);
2437
            fprintf(stderr, "\n");
2438
        }
2439
    }
2440

    
2441
    if (ret) {
2442
        fprintf(stderr, "%s\n", error);
2443
        goto fail;
2444
    }
2445

    
2446
    if (want_sdp) {
2447
        print_sdp(output_files, nb_output_files);
2448
    }
2449

    
2450
    if (!using_stdin && verbose >= 0) {
2451
#if HAVE_KBHIT
2452
        fprintf(stderr, "Press [q] to stop encoding\n");
2453
#else
2454
        fprintf(stderr, "Press ctrl-c to stop encoding\n");
2455
#endif
2456
        avio_set_interrupt_cb(decode_interrupt_cb);
2457
    }
2458
    term_init();
2459

    
2460
    timer_start = av_gettime();
2461

    
2462
    for(; received_sigterm == 0;) {
2463
        int file_index, ist_index;
2464
        AVPacket pkt;
2465
        double ipts_min;
2466
        double opts_min;
2467

    
2468
    redo:
2469
        ipts_min= 1e100;
2470
        opts_min= 1e100;
2471
        /* if 'q' pressed, exits */
2472
        if (!using_stdin) {
2473
            if (q_pressed)
2474
                break;
2475
            /* read_key() returns 0 on EOF */
2476
            key = read_key();
2477
            if (key == 'q')
2478
                break;
2479
        }
2480

    
2481
        /* select the stream that we must read now by looking at the
2482
           smallest output pts */
2483
        file_index = -1;
2484
        for(i=0;i<nb_ostreams;i++) {
2485
            double ipts, opts;
2486
            ost = ost_table[i];
2487
            os = output_files[ost->file_index];
2488
            ist = ist_table[ost->source_index];
2489
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2490
                continue;
2491
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2492
            ipts = (double)ist->pts;
2493
            if (!file_table[ist->file_index].eof_reached){
2494
                if(ipts < ipts_min) {
2495
                    ipts_min = ipts;
2496
                    if(input_sync ) file_index = ist->file_index;
2497
                }
2498
                if(opts < opts_min) {
2499
                    opts_min = opts;
2500
                    if(!input_sync) file_index = ist->file_index;
2501
                }
2502
            }
2503
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2504
                file_index= -1;
2505
                break;
2506
            }
2507
        }
2508
        /* if none, if is finished */
2509
        if (file_index < 0) {
2510
            if(no_packet_count){
2511
                no_packet_count=0;
2512
                memset(no_packet, 0, sizeof(no_packet));
2513
                usleep(10000);
2514
                continue;
2515
            }
2516
            break;
2517
        }
2518

    
2519
        /* finish if limit size exhausted */
2520
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2521
            break;
2522

    
2523
        /* read a frame from it and output it in the fifo */
2524
        is = input_files[file_index];
2525
        ret= av_read_frame(is, &pkt);
2526
        if(ret == AVERROR(EAGAIN)){
2527
            no_packet[file_index]=1;
2528
            no_packet_count++;
2529
            continue;
2530
        }
2531
        if (ret < 0) {
2532
            file_table[file_index].eof_reached = 1;
2533
            if (opt_shortest)
2534
                break;
2535
            else
2536
                continue;
2537
        }
2538

    
2539
        no_packet_count=0;
2540
        memset(no_packet, 0, sizeof(no_packet));
2541

    
2542
        if (do_pkt_dump) {
2543
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2544
                             is->streams[pkt.stream_index]);
2545
        }
2546
        /* the following test is needed in case new streams appear
2547
           dynamically in stream : we ignore them */
2548
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2549
            goto discard_packet;
2550
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2551
        ist = ist_table[ist_index];
2552
        if (ist->discard)
2553
            goto discard_packet;
2554

    
2555
        if (pkt.dts != AV_NOPTS_VALUE)
2556
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2557
        if (pkt.pts != AV_NOPTS_VALUE)
2558
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2559

    
2560
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2561
            && input_files_ts_scale[file_index][pkt.stream_index]){
2562
            if(pkt.pts != AV_NOPTS_VALUE)
2563
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2564
            if(pkt.dts != AV_NOPTS_VALUE)
2565
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2566
        }
2567

    
2568
//        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);
2569
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2570
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2571
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2572
            int64_t delta= pkt_dts - ist->next_pts;
2573
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2574
                input_files_ts_offset[ist->file_index]-= delta;
2575
                if (verbose > 2)
2576
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2577
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2578
                if(pkt.pts != AV_NOPTS_VALUE)
2579
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2580
            }
2581
        }
2582

    
2583
        /* finish if recording time exhausted */
2584
        if (recording_time != INT64_MAX &&
2585
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2586
            ist->is_past_recording_time = 1;
2587
            goto discard_packet;
2588
        }
2589

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

    
2593
            if (verbose >= 0)
2594
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2595
                        ist->file_index, ist->index);
2596
            if (exit_on_error)
2597
                ffmpeg_exit(1);
2598
            av_free_packet(&pkt);
2599
            goto redo;
2600
        }
2601

    
2602
    discard_packet:
2603
        av_free_packet(&pkt);
2604

    
2605
        /* dump report by using the output first video and audio streams */
2606
        print_report(output_files, ost_table, nb_ostreams, 0);
2607
    }
2608

    
2609
    /* at the end of stream, we must flush the decoder buffers */
2610
    for(i=0;i<nb_istreams;i++) {
2611
        ist = ist_table[i];
2612
        if (ist->decoding_needed) {
2613
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2614
        }
2615
    }
2616

    
2617
    term_exit();
2618

    
2619
    /* write the trailer if needed and close file */
2620
    for(i=0;i<nb_output_files;i++) {
2621
        os = output_files[i];
2622
        av_write_trailer(os);
2623
    }
2624

    
2625
    /* dump report by using the first video and audio streams */
2626
    print_report(output_files, ost_table, nb_ostreams, 1);
2627

    
2628
    /* close each encoder */
2629
    for(i=0;i<nb_ostreams;i++) {
2630
        ost = ost_table[i];
2631
        if (ost->encoding_needed) {
2632
            av_freep(&ost->st->codec->stats_in);
2633
            avcodec_close(ost->st->codec);
2634
        }
2635
    }
2636

    
2637
    /* close each decoder */
2638
    for(i=0;i<nb_istreams;i++) {
2639
        ist = ist_table[i];
2640
        if (ist->decoding_needed) {
2641
            avcodec_close(ist->st->codec);
2642
        }
2643
    }
2644
#if CONFIG_AVFILTER
2645
    avfilter_graph_free(&graph);
2646
#endif
2647

    
2648
    /* finished ! */
2649
    ret = 0;
2650

    
2651
 fail:
2652
    av_freep(&bit_buffer);
2653
    av_free(file_table);
2654

    
2655
    if (ist_table) {
2656
        for(i=0;i<nb_istreams;i++) {
2657
            ist = ist_table[i];
2658
            av_free(ist);
2659
        }
2660
        av_free(ist_table);
2661
    }
2662
    if (ost_table) {
2663
        for(i=0;i<nb_ostreams;i++) {
2664
            ost = ost_table[i];
2665
            if (ost) {
2666
                if (ost->st->stream_copy)
2667
                    av_freep(&ost->st->codec->extradata);
2668
                if (ost->logfile) {
2669
                    fclose(ost->logfile);
2670
                    ost->logfile = NULL;
2671
                }
2672
                av_fifo_free(ost->fifo); /* works even if fifo is not
2673
                                             initialized but set to zero */
2674
                av_freep(&ost->st->codec->subtitle_header);
2675
                av_free(ost->pict_tmp.data[0]);
2676
                av_free(ost->forced_kf_pts);
2677
                if (ost->video_resample)
2678
                    sws_freeContext(ost->img_resample_ctx);
2679
                if (ost->resample)
2680
                    audio_resample_close(ost->resample);
2681
                if (ost->reformat_ctx)
2682
                    av_audio_convert_free(ost->reformat_ctx);
2683
                av_free(ost);
2684
            }
2685
        }
2686
        av_free(ost_table);
2687
    }
2688
    return ret;
2689
}
2690

    
2691
static void opt_format(const char *arg)
2692
{
2693
    last_asked_format = arg;
2694
}
2695

    
2696
static void opt_video_rc_override_string(const char *arg)
2697
{
2698
    video_rc_override_string = arg;
2699
}
2700

    
2701
static int opt_me_threshold(const char *opt, const char *arg)
2702
{
2703
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2704
    return 0;
2705
}
2706

    
2707
static int opt_verbose(const char *opt, const char *arg)
2708
{
2709
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2710
    return 0;
2711
}
2712

    
2713
static int opt_frame_rate(const char *opt, const char *arg)
2714
{
2715
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2716
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2717
        ffmpeg_exit(1);
2718
    }
2719
    return 0;
2720
}
2721

    
2722
static int opt_bitrate(const char *opt, const char *arg)
2723
{
2724
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2725

    
2726
    opt_default(opt, arg);
2727

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

    
2731
    return 0;
2732
}
2733

    
2734
static int opt_frame_crop(const char *opt, const char *arg)
2735
{
2736
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2737
    return AVERROR(EINVAL);
2738
}
2739

    
2740
static void opt_frame_size(const char *arg)
2741
{
2742
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2743
        fprintf(stderr, "Incorrect frame size\n");
2744
        ffmpeg_exit(1);
2745
    }
2746
}
2747

    
2748
static int opt_pad(const char *opt, const char *arg) {
2749
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2750
    return -1;
2751
}
2752

    
2753
static void opt_frame_pix_fmt(const char *arg)
2754
{
2755
    if (strcmp(arg, "list")) {
2756
        frame_pix_fmt = av_get_pix_fmt(arg);
2757
        if (frame_pix_fmt == PIX_FMT_NONE) {
2758
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2759
            ffmpeg_exit(1);
2760
        }
2761
    } else {
2762
        show_pix_fmts();
2763
        ffmpeg_exit(0);
2764
    }
2765
}
2766

    
2767
static void opt_frame_aspect_ratio(const char *arg)
2768
{
2769
    int x = 0, y = 0;
2770
    double ar = 0;
2771
    const char *p;
2772
    char *end;
2773

    
2774
    p = strchr(arg, ':');
2775
    if (p) {
2776
        x = strtol(arg, &end, 10);
2777
        if (end == p)
2778
            y = strtol(end+1, &end, 10);
2779
        if (x > 0 && y > 0)
2780
            ar = (double)x / (double)y;
2781
    } else
2782
        ar = strtod(arg, NULL);
2783

    
2784
    if (!ar) {
2785
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2786
        ffmpeg_exit(1);
2787
    }
2788
    frame_aspect_ratio = ar;
2789
}
2790

    
2791
static int opt_metadata(const char *opt, const char *arg)
2792
{
2793
    char *mid= strchr(arg, '=');
2794

    
2795
    if(!mid){
2796
        fprintf(stderr, "Missing =\n");
2797
        ffmpeg_exit(1);
2798
    }
2799
    *mid++= 0;
2800

    
2801
    av_metadata_set2(&metadata, arg, mid, 0);
2802

    
2803
    return 0;
2804
}
2805

    
2806
static void opt_qscale(const char *arg)
2807
{
2808
    video_qscale = atof(arg);
2809
    if (video_qscale <= 0 ||
2810
        video_qscale > 255) {
2811
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2812
        ffmpeg_exit(1);
2813
    }
2814
}
2815

    
2816
static void opt_top_field_first(const char *arg)
2817
{
2818
    top_field_first= atoi(arg);
2819
}
2820

    
2821
static int opt_thread_count(const char *opt, const char *arg)
2822
{
2823
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2824
#if !HAVE_THREADS
2825
    if (verbose >= 0)
2826
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2827
#endif
2828
    return 0;
2829
}
2830

    
2831
static void opt_audio_sample_fmt(const char *arg)
2832
{
2833
    if (strcmp(arg, "list")) {
2834
        audio_sample_fmt = av_get_sample_fmt(arg);
2835
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2836
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2837
            ffmpeg_exit(1);
2838
        }
2839
    } else {
2840
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2841
        ffmpeg_exit(0);
2842
    }
2843
}
2844

    
2845
static int opt_audio_rate(const char *opt, const char *arg)
2846
{
2847
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2848
    return 0;
2849
}
2850

    
2851
static int opt_audio_channels(const char *opt, const char *arg)
2852
{
2853
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2854
    return 0;
2855
}
2856

    
2857
static void opt_video_channel(const char *arg)
2858
{
2859
    video_channel = strtol(arg, NULL, 0);
2860
}
2861

    
2862
static void opt_video_standard(const char *arg)
2863
{
2864
    video_standard = av_strdup(arg);
2865
}
2866

    
2867
static void opt_codec(int *pstream_copy, char **pcodec_name,
2868
                      int codec_type, const char *arg)
2869
{
2870
    av_freep(pcodec_name);
2871
    if (!strcmp(arg, "copy")) {
2872
        *pstream_copy = 1;
2873
    } else {
2874
        *pcodec_name = av_strdup(arg);
2875
    }
2876
}
2877

    
2878
static void opt_audio_codec(const char *arg)
2879
{
2880
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2881
}
2882

    
2883
static void opt_video_codec(const char *arg)
2884
{
2885
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2886
}
2887

    
2888
static void opt_subtitle_codec(const char *arg)
2889
{
2890
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2891
}
2892

    
2893
static int opt_codec_tag(const char *opt, const char *arg)
2894
{
2895
    char *tail;
2896
    uint32_t *codec_tag;
2897

    
2898
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2899
                !strcmp(opt, "vtag") ? &video_codec_tag :
2900
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2901
    if (!codec_tag)
2902
        return -1;
2903

    
2904
    *codec_tag = strtol(arg, &tail, 0);
2905
    if (!tail || *tail)
2906
        *codec_tag = AV_RL32(arg);
2907

    
2908
    return 0;
2909
}
2910

    
2911
static void opt_map(const char *arg)
2912
{
2913
    AVStreamMap *m;
2914
    char *p;
2915

    
2916
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2917
    m = &stream_maps[nb_stream_maps-1];
2918

    
2919
    m->file_index = strtol(arg, &p, 0);
2920
    if (*p)
2921
        p++;
2922

    
2923
    m->stream_index = strtol(p, &p, 0);
2924
    if (*p) {
2925
        p++;
2926
        m->sync_file_index = strtol(p, &p, 0);
2927
        if (*p)
2928
            p++;
2929
        m->sync_stream_index = strtol(p, &p, 0);
2930
    } else {
2931
        m->sync_file_index = m->file_index;
2932
        m->sync_stream_index = m->stream_index;
2933
    }
2934
}
2935

    
2936
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2937
{
2938
    *endptr = arg;
2939
    if (*arg == ',') {
2940
        *type = *(++arg);
2941
        switch (*arg) {
2942
        case 'g':
2943
            break;
2944
        case 's':
2945
        case 'c':
2946
        case 'p':
2947
            *index = strtol(++arg, endptr, 0);
2948
            break;
2949
        default:
2950
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2951
            ffmpeg_exit(1);
2952
        }
2953
    } else
2954
        *type = 'g';
2955
}
2956

    
2957
static void opt_map_metadata(const char *arg)
2958
{
2959
    AVMetaDataMap *m, *m1;
2960
    char *p;
2961

    
2962
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2963
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2964

    
2965
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
2966
    m->file = strtol(arg, &p, 0);
2967
    parse_meta_type(p, &m->type, &m->index, &p);
2968
    if (*p)
2969
        p++;
2970

    
2971
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2972
    m1->file = strtol(p, &p, 0);
2973
    parse_meta_type(p, &m1->type, &m1->index, &p);
2974

    
2975
    if (m->type == 'g' || m1->type == 'g')
2976
        metadata_global_autocopy = 0;
2977
    if (m->type == 's' || m1->type == 's')
2978
        metadata_streams_autocopy = 0;
2979
    if (m->type == 'c' || m1->type == 'c')
2980
        metadata_chapters_autocopy = 0;
2981
}
2982

    
2983
static void opt_map_meta_data(const char *arg)
2984
{
2985
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2986
                    "Use -map_metadata instead.\n");
2987
    opt_map_metadata(arg);
2988
}
2989

    
2990
static void opt_map_chapters(const char *arg)
2991
{
2992
    AVChapterMap *c;
2993
    char *p;
2994

    
2995
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
2996
                              nb_chapter_maps + 1);
2997
    c = &chapter_maps[nb_chapter_maps - 1];
2998
    c->out_file = strtol(arg, &p, 0);
2999
    if (*p)
3000
        p++;
3001

    
3002
    c->in_file = strtol(p, &p, 0);
3003
}
3004

    
3005
static void opt_input_ts_scale(const char *arg)
3006
{
3007
    unsigned int stream;
3008
    double scale;
3009
    char *p;
3010

    
3011
    stream = strtol(arg, &p, 0);
3012
    if (*p)
3013
        p++;
3014
    scale= strtod(p, &p);
3015

    
3016
    if(stream >= MAX_STREAMS)
3017
        ffmpeg_exit(1);
3018

    
3019
    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);
3020
    input_files_ts_scale[nb_input_files][stream]= scale;
3021
}
3022

    
3023
static int opt_recording_time(const char *opt, const char *arg)
3024
{
3025
    recording_time = parse_time_or_die(opt, arg, 1);
3026
    return 0;
3027
}
3028

    
3029
static int opt_start_time(const char *opt, const char *arg)
3030
{
3031
    start_time = parse_time_or_die(opt, arg, 1);
3032
    return 0;
3033
}
3034

    
3035
static int opt_recording_timestamp(const char *opt, const char *arg)
3036
{
3037
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3038
    return 0;
3039
}
3040

    
3041
static int opt_input_ts_offset(const char *opt, const char *arg)
3042
{
3043
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3044
    return 0;
3045
}
3046

    
3047
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3048
{
3049
    const char *codec_string = encoder ? "encoder" : "decoder";
3050
    AVCodec *codec;
3051

    
3052
    if(!name)
3053
        return CODEC_ID_NONE;
3054
    codec = encoder ?
3055
        avcodec_find_encoder_by_name(name) :
3056
        avcodec_find_decoder_by_name(name);
3057
    if(!codec) {
3058
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3059
        ffmpeg_exit(1);
3060
    }
3061
    if(codec->type != type) {
3062
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3063
        ffmpeg_exit(1);
3064
    }
3065
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3066
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3067
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3068
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3069
                codec_string, codec->name);
3070
        codec = encoder ?
3071
            avcodec_find_encoder(codec->id) :
3072
            avcodec_find_decoder(codec->id);
3073
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3074
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3075
                    codec_string, codec->name);
3076
        ffmpeg_exit(1);
3077
    }
3078
    return codec->id;
3079
}
3080

    
3081
static void opt_input_file(const char *filename)
3082
{
3083
    AVFormatContext *ic;
3084
    AVFormatParameters params, *ap = &params;
3085
    AVInputFormat *file_iformat = NULL;
3086
    int err, i, ret, rfps, rfps_base;
3087
    int64_t timestamp;
3088

    
3089
    if (last_asked_format) {
3090
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3091
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3092
            ffmpeg_exit(1);
3093
        }
3094
        last_asked_format = NULL;
3095
    }
3096

    
3097
    if (!strcmp(filename, "-"))
3098
        filename = "pipe:";
3099

    
3100
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3101
                    !strcmp(filename, "/dev/stdin");
3102

    
3103
    /* get default parameters from command line */
3104
    ic = avformat_alloc_context();
3105
    if (!ic) {
3106
        print_error(filename, AVERROR(ENOMEM));
3107
        ffmpeg_exit(1);
3108
    }
3109

    
3110
    memset(ap, 0, sizeof(*ap));
3111
    ap->prealloced_context = 1;
3112
    ap->sample_rate = audio_sample_rate;
3113
    ap->channels = audio_channels;
3114
    ap->time_base.den = frame_rate.num;
3115
    ap->time_base.num = frame_rate.den;
3116
    ap->width = frame_width;
3117
    ap->height = frame_height;
3118
    ap->pix_fmt = frame_pix_fmt;
3119
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3120
    ap->channel = video_channel;
3121
    ap->standard = video_standard;
3122

    
3123
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3124

    
3125
    ic->video_codec_id   =
3126
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3127
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3128
    ic->audio_codec_id   =
3129
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3130
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3131
    ic->subtitle_codec_id=
3132
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3133
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3134
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3135

    
3136
    /* open the input file with generic libav function */
3137
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3138
    if (err < 0) {
3139
        print_error(filename, err);
3140
        ffmpeg_exit(1);
3141
    }
3142
    if(opt_programid) {
3143
        int i, j;
3144
        int found=0;
3145
        for(i=0; i<ic->nb_streams; i++){
3146
            ic->streams[i]->discard= AVDISCARD_ALL;
3147
        }
3148
        for(i=0; i<ic->nb_programs; i++){
3149
            AVProgram *p= ic->programs[i];
3150
            if(p->id != opt_programid){
3151
                p->discard = AVDISCARD_ALL;
3152
            }else{
3153
                found=1;
3154
                for(j=0; j<p->nb_stream_indexes; j++){
3155
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3156
                }
3157
            }
3158
        }
3159
        if(!found){
3160
            fprintf(stderr, "Specified program id not found\n");
3161
            ffmpeg_exit(1);
3162
        }
3163
        opt_programid=0;
3164
    }
3165

    
3166
    ic->loop_input = loop_input;
3167

    
3168
    /* If not enough info to get the stream parameters, we decode the
3169
       first frames to get it. (used in mpeg case for example) */
3170
    ret = av_find_stream_info(ic);
3171
    if (ret < 0 && verbose >= 0) {
3172
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3173
        av_close_input_file(ic);
3174
        ffmpeg_exit(1);
3175
    }
3176

    
3177
    timestamp = start_time;
3178
    /* add the stream start time */
3179
    if (ic->start_time != AV_NOPTS_VALUE)
3180
        timestamp += ic->start_time;
3181

    
3182
    /* if seeking requested, we execute it */
3183
    if (start_time != 0) {
3184
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3185
        if (ret < 0) {
3186
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3187
                    filename, (double)timestamp / AV_TIME_BASE);
3188
        }
3189
        /* reset seek info */
3190
        start_time = 0;
3191
    }
3192

    
3193
    /* update the current parameters so that they match the one of the input stream */
3194
    for(i=0;i<ic->nb_streams;i++) {
3195
        AVStream *st = ic->streams[i];
3196
        AVCodecContext *dec = st->codec;
3197
        dec->thread_count = thread_count;
3198
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3199
        switch (dec->codec_type) {
3200
        case AVMEDIA_TYPE_AUDIO:
3201
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3202
            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]);
3203
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3204
            channel_layout    = dec->channel_layout;
3205
            audio_channels    = dec->channels;
3206
            audio_sample_rate = dec->sample_rate;
3207
            audio_sample_fmt  = dec->sample_fmt;
3208
            if(audio_disable)
3209
                st->discard= AVDISCARD_ALL;
3210
            /* Note that av_find_stream_info can add more streams, and we
3211
             * currently have no chance of setting up lowres decoding
3212
             * early enough for them. */
3213
            if (dec->lowres)
3214
                audio_sample_rate >>= dec->lowres;
3215
            break;
3216
        case AVMEDIA_TYPE_VIDEO:
3217
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3218
            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]);
3219
            frame_height = dec->height;
3220
            frame_width  = dec->width;
3221
            if(ic->streams[i]->sample_aspect_ratio.num)
3222
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3223
            else
3224
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3225
            frame_aspect_ratio *= (float) dec->width / dec->height;
3226
            frame_pix_fmt = dec->pix_fmt;
3227
            rfps      = ic->streams[i]->r_frame_rate.num;
3228
            rfps_base = ic->streams[i]->r_frame_rate.den;
3229
            if (dec->lowres) {
3230
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3231
                frame_height >>= dec->lowres;
3232
                frame_width  >>= dec->lowres;
3233
                dec->height = frame_height;
3234
                dec->width  = frame_width;
3235
            }
3236
            if(me_threshold)
3237
                dec->debug |= FF_DEBUG_MV;
3238

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

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

    
3245
                    (float)rfps / rfps_base, rfps, rfps_base);
3246
            }
3247
            /* update the current frame rate to match the stream frame rate */
3248
            frame_rate.num = rfps;
3249
            frame_rate.den = rfps_base;
3250

    
3251
            if(video_disable)
3252
                st->discard= AVDISCARD_ALL;
3253
            else if(video_discard)
3254
                st->discard= video_discard;
3255
            break;
3256
        case AVMEDIA_TYPE_DATA:
3257
            break;
3258
        case AVMEDIA_TYPE_SUBTITLE:
3259
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3260
            if(subtitle_disable)
3261
                st->discard = AVDISCARD_ALL;
3262
            break;
3263
        case AVMEDIA_TYPE_ATTACHMENT:
3264
        case AVMEDIA_TYPE_UNKNOWN:
3265
            break;
3266
        default:
3267
            abort();
3268
        }
3269
    }
3270

    
3271
    input_files[nb_input_files] = ic;
3272
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3273
    /* dump the file content */
3274
    if (verbose >= 0)
3275
        av_dump_format(ic, nb_input_files, filename, 0);
3276

    
3277
    nb_input_files++;
3278

    
3279
    video_channel = 0;
3280

    
3281
    av_freep(&video_codec_name);
3282
    av_freep(&audio_codec_name);
3283
    av_freep(&subtitle_codec_name);
3284
}
3285

    
3286
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3287
                                         int *has_subtitle_ptr)
3288
{
3289
    int has_video, has_audio, has_subtitle, i, j;
3290
    AVFormatContext *ic;
3291

    
3292
    has_video = 0;
3293
    has_audio = 0;
3294
    has_subtitle = 0;
3295
    for(j=0;j<nb_input_files;j++) {
3296
        ic = input_files[j];
3297
        for(i=0;i<ic->nb_streams;i++) {
3298
            AVCodecContext *enc = ic->streams[i]->codec;
3299
            switch(enc->codec_type) {
3300
            case AVMEDIA_TYPE_AUDIO:
3301
                has_audio = 1;
3302
                break;
3303
            case AVMEDIA_TYPE_VIDEO:
3304
                has_video = 1;
3305
                break;
3306
            case AVMEDIA_TYPE_SUBTITLE:
3307
                has_subtitle = 1;
3308
                break;
3309
            case AVMEDIA_TYPE_DATA:
3310
            case AVMEDIA_TYPE_ATTACHMENT:
3311
            case AVMEDIA_TYPE_UNKNOWN:
3312
                break;
3313
            default:
3314
                abort();
3315
            }
3316
        }
3317
    }
3318
    *has_video_ptr = has_video;
3319
    *has_audio_ptr = has_audio;
3320
    *has_subtitle_ptr = has_subtitle;
3321
}
3322

    
3323
static void new_video_stream(AVFormatContext *oc, int file_idx)
3324
{
3325
    AVStream *st;
3326
    AVOutputStream *ost;
3327
    AVCodecContext *video_enc;
3328
    enum CodecID codec_id = CODEC_ID_NONE;
3329
    AVCodec *codec= NULL;
3330

    
3331
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3332
    if (!st) {
3333
        fprintf(stderr, "Could not alloc stream\n");
3334
        ffmpeg_exit(1);
3335
    }
3336
    ost = new_output_stream(oc, file_idx);
3337

    
3338
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3339
    if(!video_stream_copy){
3340
        if (video_codec_name) {
3341
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3342
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3343
            codec = avcodec_find_encoder_by_name(video_codec_name);
3344
            output_codecs[nb_output_codecs-1] = codec;
3345
        } else {
3346
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3347
            codec = avcodec_find_encoder(codec_id);
3348
        }
3349
    }
3350

    
3351
    avcodec_get_context_defaults3(st->codec, codec);
3352
    ost->bitstream_filters = video_bitstream_filters;
3353
    video_bitstream_filters= NULL;
3354

    
3355
    st->codec->thread_count= thread_count;
3356

    
3357
    video_enc = st->codec;
3358

    
3359
    if(video_codec_tag)
3360
        video_enc->codec_tag= video_codec_tag;
3361

    
3362
    if(   (video_global_header&1)
3363
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3364
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3365
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3366
    }
3367
    if(video_global_header&2){
3368
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3369
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3370
    }
3371

    
3372
    if (video_stream_copy) {
3373
        st->stream_copy = 1;
3374
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3375
        video_enc->sample_aspect_ratio =
3376
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3377
    } else {
3378
        const char *p;
3379
        int i;
3380
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3381

    
3382
        video_enc->codec_id = codec_id;
3383
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3384

    
3385
        if (codec && codec->supported_framerates && !force_fps)
3386
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3387
        video_enc->time_base.den = fps.num;
3388
        video_enc->time_base.num = fps.den;
3389

    
3390
        video_enc->width = frame_width;
3391
        video_enc->height = frame_height;
3392
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3393
        video_enc->pix_fmt = frame_pix_fmt;
3394
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3395

    
3396
        choose_pixel_fmt(st, codec);
3397

    
3398
        if (intra_only)
3399
            video_enc->gop_size = 0;
3400
        if (video_qscale || same_quality) {
3401
            video_enc->flags |= CODEC_FLAG_QSCALE;
3402
            video_enc->global_quality=
3403
                st->quality = FF_QP2LAMBDA * video_qscale;
3404
        }
3405

    
3406
        if(intra_matrix)
3407
            video_enc->intra_matrix = intra_matrix;
3408
        if(inter_matrix)
3409
            video_enc->inter_matrix = inter_matrix;
3410

    
3411
        p= video_rc_override_string;
3412
        for(i=0; p; i++){
3413
            int start, end, q;
3414
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3415
            if(e!=3){
3416
                fprintf(stderr, "error parsing rc_override\n");
3417
                ffmpeg_exit(1);
3418
            }
3419
            video_enc->rc_override=
3420
                av_realloc(video_enc->rc_override,
3421
                           sizeof(RcOverride)*(i+1));
3422
            video_enc->rc_override[i].start_frame= start;
3423
            video_enc->rc_override[i].end_frame  = end;
3424
            if(q>0){
3425
                video_enc->rc_override[i].qscale= q;
3426
                video_enc->rc_override[i].quality_factor= 1.0;
3427
            }
3428
            else{
3429
                video_enc->rc_override[i].qscale= 0;
3430
                video_enc->rc_override[i].quality_factor= -q/100.0;
3431
            }
3432
            p= strchr(p, '/');
3433
            if(p) p++;
3434
        }
3435
        video_enc->rc_override_count=i;
3436
        if (!video_enc->rc_initial_buffer_occupancy)
3437
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3438
        video_enc->me_threshold= me_threshold;
3439
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3440

    
3441
        if (do_psnr)
3442
            video_enc->flags|= CODEC_FLAG_PSNR;
3443

    
3444
        /* two pass mode */
3445
        if (do_pass) {
3446
            if (do_pass == 1) {
3447
                video_enc->flags |= CODEC_FLAG_PASS1;
3448
            } else {
3449
                video_enc->flags |= CODEC_FLAG_PASS2;
3450
            }
3451
        }
3452

    
3453
        if (forced_key_frames)
3454
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3455
    }
3456
    if (video_language) {
3457
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3458
        av_freep(&video_language);
3459
    }
3460

    
3461
    /* reset some key parameters */
3462
    video_disable = 0;
3463
    av_freep(&video_codec_name);
3464
    av_freep(&forced_key_frames);
3465
    video_stream_copy = 0;
3466
    frame_pix_fmt = PIX_FMT_NONE;
3467
}
3468

    
3469
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3470
{
3471
    AVStream *st;
3472
    AVOutputStream *ost;
3473
    AVCodec *codec= NULL;
3474
    AVCodecContext *audio_enc;
3475
    enum CodecID codec_id = CODEC_ID_NONE;
3476

    
3477
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3478
    if (!st) {
3479
        fprintf(stderr, "Could not alloc stream\n");
3480
        ffmpeg_exit(1);
3481
    }
3482
    ost = new_output_stream(oc, file_idx);
3483

    
3484
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3485
    if(!audio_stream_copy){
3486
        if (audio_codec_name) {
3487
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3488
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3489
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3490
            output_codecs[nb_output_codecs-1] = codec;
3491
        } else {
3492
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3493
            codec = avcodec_find_encoder(codec_id);
3494
        }
3495
    }
3496

    
3497
    avcodec_get_context_defaults3(st->codec, codec);
3498

    
3499
    ost->bitstream_filters = audio_bitstream_filters;
3500
    audio_bitstream_filters= NULL;
3501

    
3502
    st->codec->thread_count= thread_count;
3503

    
3504
    audio_enc = st->codec;
3505
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3506

    
3507
    if(audio_codec_tag)
3508
        audio_enc->codec_tag= audio_codec_tag;
3509

    
3510
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3511
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3512
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3513
    }
3514
    if (audio_stream_copy) {
3515
        st->stream_copy = 1;
3516
        audio_enc->channels = audio_channels;
3517
        audio_enc->sample_rate = audio_sample_rate;
3518
    } else {
3519
        audio_enc->codec_id = codec_id;
3520
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3521

    
3522
        if (audio_qscale > QSCALE_NONE) {
3523
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3524
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3525
        }
3526
        audio_enc->channels = audio_channels;
3527
        audio_enc->sample_fmt = audio_sample_fmt;
3528
        audio_enc->sample_rate = audio_sample_rate;
3529
        audio_enc->channel_layout = channel_layout;
3530
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3531
            audio_enc->channel_layout = 0;
3532
        choose_sample_fmt(st, codec);
3533
        choose_sample_rate(st, codec);
3534
    }
3535
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3536
    if (audio_language) {
3537
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3538
        av_freep(&audio_language);
3539
    }
3540

    
3541
    /* reset some key parameters */
3542
    audio_disable = 0;
3543
    av_freep(&audio_codec_name);
3544
    audio_stream_copy = 0;
3545
}
3546

    
3547
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3548
{
3549
    AVStream *st;
3550
    AVOutputStream *ost;
3551
    AVCodec *codec=NULL;
3552
    AVCodecContext *subtitle_enc;
3553
    enum CodecID codec_id = CODEC_ID_NONE;
3554

    
3555
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3556
    if (!st) {
3557
        fprintf(stderr, "Could not alloc stream\n");
3558
        ffmpeg_exit(1);
3559
    }
3560
    ost = new_output_stream(oc, file_idx);
3561
    subtitle_enc = st->codec;
3562
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3563
    if(!subtitle_stream_copy){
3564
        if (subtitle_codec_name) {
3565
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3566
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3567
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3568
        } else {
3569
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3570
            codec = avcodec_find_encoder(codec_id);
3571
        }
3572
    }
3573
    avcodec_get_context_defaults3(st->codec, codec);
3574

    
3575
    ost->bitstream_filters = subtitle_bitstream_filters;
3576
    subtitle_bitstream_filters= NULL;
3577

    
3578
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3579

    
3580
    if(subtitle_codec_tag)
3581
        subtitle_enc->codec_tag= subtitle_codec_tag;
3582

    
3583
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3584
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3585
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3586
    }
3587
    if (subtitle_stream_copy) {
3588
        st->stream_copy = 1;
3589
    } else {
3590
        subtitle_enc->codec_id = codec_id;
3591
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3592
    }
3593

    
3594
    if (subtitle_language) {
3595
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3596
        av_freep(&subtitle_language);
3597
    }
3598

    
3599
    subtitle_disable = 0;
3600
    av_freep(&subtitle_codec_name);
3601
    subtitle_stream_copy = 0;
3602
}
3603

    
3604
static int opt_new_stream(const char *opt, const char *arg)
3605
{
3606
    AVFormatContext *oc;
3607
    int file_idx = nb_output_files - 1;
3608
    if (nb_output_files <= 0) {
3609
        fprintf(stderr, "At least one output file must be specified\n");
3610
        ffmpeg_exit(1);
3611
    }
3612
    oc = output_files[file_idx];
3613

    
3614
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3615
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3616
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3617
    else av_assert0(0);
3618
    return 0;
3619
}
3620

    
3621
/* arg format is "output-stream-index:streamid-value". */
3622
static int opt_streamid(const char *opt, const char *arg)
3623
{
3624
    int idx;
3625
    char *p;
3626
    char idx_str[16];
3627

    
3628
    strncpy(idx_str, arg, sizeof(idx_str));
3629
    idx_str[sizeof(idx_str)-1] = '\0';
3630
    p = strchr(idx_str, ':');
3631
    if (!p) {
3632
        fprintf(stderr,
3633
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3634
                arg, opt);
3635
        ffmpeg_exit(1);
3636
    }
3637
    *p++ = '\0';
3638
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3639
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3640
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3641
    return 0;
3642
}
3643

    
3644
static void opt_output_file(const char *filename)
3645
{
3646
    AVFormatContext *oc;
3647
    int err, use_video, use_audio, use_subtitle;
3648
    int input_has_video, input_has_audio, input_has_subtitle;
3649
    AVFormatParameters params, *ap = &params;
3650
    AVOutputFormat *file_oformat;
3651

    
3652
    if (!strcmp(filename, "-"))
3653
        filename = "pipe:";
3654

    
3655
    oc = avformat_alloc_context();
3656
    if (!oc) {
3657
        print_error(filename, AVERROR(ENOMEM));
3658
        ffmpeg_exit(1);
3659
    }
3660

    
3661
    if (last_asked_format) {
3662
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3663
        if (!file_oformat) {
3664
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3665
            ffmpeg_exit(1);
3666
        }
3667
        last_asked_format = NULL;
3668
    } else {
3669
        file_oformat = av_guess_format(NULL, filename, NULL);
3670
        if (!file_oformat) {
3671
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3672
                    filename);
3673
            ffmpeg_exit(1);
3674
        }
3675
    }
3676

    
3677
    oc->oformat = file_oformat;
3678
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3679

    
3680
    if (!strcmp(file_oformat->name, "ffm") &&
3681
        av_strstart(filename, "http:", NULL)) {
3682
        /* special case for files sent to ffserver: we get the stream
3683
           parameters from ffserver */
3684
        int err = read_ffserver_streams(oc, filename);
3685
        if (err < 0) {
3686
            print_error(filename, err);
3687
            ffmpeg_exit(1);
3688
        }
3689
    } else {
3690
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3691
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3692
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3693

    
3694
        /* disable if no corresponding type found and at least one
3695
           input file */
3696
        if (nb_input_files > 0) {
3697
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3698
                                         &input_has_subtitle);
3699
            if (!input_has_video)
3700
                use_video = 0;
3701
            if (!input_has_audio)
3702
                use_audio = 0;
3703
            if (!input_has_subtitle)
3704
                use_subtitle = 0;
3705
        }
3706

    
3707
        /* manual disable */
3708
        if (audio_disable)    use_audio    = 0;
3709
        if (video_disable)    use_video    = 0;
3710
        if (subtitle_disable) use_subtitle = 0;
3711

    
3712
        if (use_video)    new_video_stream(oc, nb_output_files);
3713
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3714
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3715

    
3716
        oc->timestamp = recording_timestamp;
3717

    
3718
        av_metadata_copy(&oc->metadata, metadata, 0);
3719
        av_metadata_free(&metadata);
3720
    }
3721

    
3722
    output_files[nb_output_files++] = oc;
3723

    
3724
    /* check filename in case of an image number is expected */
3725
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3726
        if (!av_filename_number_test(oc->filename)) {
3727
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3728
            ffmpeg_exit(1);
3729
        }
3730
    }
3731

    
3732
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3733
        /* test if it already exists to avoid loosing precious files */
3734
        if (!file_overwrite &&
3735
            (strchr(filename, ':') == NULL ||
3736
             filename[1] == ':' ||
3737
             av_strstart(filename, "file:", NULL))) {
3738
            if (url_exist(filename)) {
3739
                if (!using_stdin) {
3740
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3741
                    fflush(stderr);
3742
                    if (!read_yesno()) {
3743
                        fprintf(stderr, "Not overwriting - exiting\n");
3744
                        ffmpeg_exit(1);
3745
                    }
3746
                }
3747
                else {
3748
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3749
                    ffmpeg_exit(1);
3750
                }
3751
            }
3752
        }
3753

    
3754
        /* open the file */
3755
        if ((err = avio_open(&oc->pb, filename, AVIO_WRONLY)) < 0) {
3756
            print_error(filename, err);
3757
            ffmpeg_exit(1);
3758
        }
3759
    }
3760

    
3761
    memset(ap, 0, sizeof(*ap));
3762
    if (av_set_parameters(oc, ap) < 0) {
3763
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3764
                oc->filename);
3765
        ffmpeg_exit(1);
3766
    }
3767

    
3768
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3769
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3770
    oc->loop_output = loop_output;
3771
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3772

    
3773
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3774

    
3775
    av_freep(&forced_key_frames);
3776
}
3777

    
3778
/* same option as mencoder */
3779
static void opt_pass(const char *pass_str)
3780
{
3781
    int pass;
3782
    pass = atoi(pass_str);
3783
    if (pass != 1 && pass != 2) {
3784
        fprintf(stderr, "pass number can be only 1 or 2\n");
3785
        ffmpeg_exit(1);
3786
    }
3787
    do_pass = pass;
3788
}
3789

    
3790
static int64_t getutime(void)
3791
{
3792
#if HAVE_GETRUSAGE
3793
    struct rusage rusage;
3794

    
3795
    getrusage(RUSAGE_SELF, &rusage);
3796
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3797
#elif HAVE_GETPROCESSTIMES
3798
    HANDLE proc;
3799
    FILETIME c, e, k, u;
3800
    proc = GetCurrentProcess();
3801
    GetProcessTimes(proc, &c, &e, &k, &u);
3802
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3803
#else
3804
    return av_gettime();
3805
#endif
3806
}
3807

    
3808
static int64_t getmaxrss(void)
3809
{
3810
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3811
    struct rusage rusage;
3812
    getrusage(RUSAGE_SELF, &rusage);
3813
    return (int64_t)rusage.ru_maxrss * 1024;
3814
#elif HAVE_GETPROCESSMEMORYINFO
3815
    HANDLE proc;
3816
    PROCESS_MEMORY_COUNTERS memcounters;
3817
    proc = GetCurrentProcess();
3818
    memcounters.cb = sizeof(memcounters);
3819
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3820
    return memcounters.PeakPagefileUsage;
3821
#else
3822
    return 0;
3823
#endif
3824
}
3825

    
3826
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3827
{
3828
    int i;
3829
    const char *p = str;
3830
    for(i = 0;; i++) {
3831
        dest[i] = atoi(p);
3832
        if(i == 63)
3833
            break;
3834
        p = strchr(p, ',');
3835
        if(!p) {
3836
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3837
            ffmpeg_exit(1);
3838
        }
3839
        p++;
3840
    }
3841
}
3842

    
3843
static void opt_inter_matrix(const char *arg)
3844
{
3845
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3846
    parse_matrix_coeffs(inter_matrix, arg);
3847
}
3848

    
3849
static void opt_intra_matrix(const char *arg)
3850
{
3851
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3852
    parse_matrix_coeffs(intra_matrix, arg);
3853
}
3854

    
3855
static void show_usage(void)
3856
{
3857
    printf("Hyper fast Audio and Video encoder\n");
3858
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3859
    printf("\n");
3860
}
3861

    
3862
static void show_help(void)
3863
{
3864
    AVCodec *c;
3865
    AVOutputFormat *oformat = NULL;
3866

    
3867
    av_log_set_callback(log_callback_help);
3868
    show_usage();
3869
    show_help_options(options, "Main options:\n",
3870
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3871
    show_help_options(options, "\nAdvanced options:\n",
3872
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3873
                      OPT_EXPERT);
3874
    show_help_options(options, "\nVideo options:\n",
3875
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3876
                      OPT_VIDEO);
3877
    show_help_options(options, "\nAdvanced Video options:\n",
3878
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3879
                      OPT_VIDEO | OPT_EXPERT);
3880
    show_help_options(options, "\nAudio options:\n",
3881
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3882
                      OPT_AUDIO);
3883
    show_help_options(options, "\nAdvanced Audio options:\n",
3884
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3885
                      OPT_AUDIO | OPT_EXPERT);
3886
    show_help_options(options, "\nSubtitle options:\n",
3887
                      OPT_SUBTITLE | OPT_GRAB,
3888
                      OPT_SUBTITLE);
3889
    show_help_options(options, "\nAudio/Video grab options:\n",
3890
                      OPT_GRAB,
3891
                      OPT_GRAB);
3892
    printf("\n");
3893
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3894
    printf("\n");
3895

    
3896
    /* individual codec options */
3897
    c = NULL;
3898
    while ((c = av_codec_next(c))) {
3899
        if (c->priv_class) {
3900
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3901
            printf("\n");
3902
        }
3903
    }
3904

    
3905
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3906
    printf("\n");
3907

    
3908
    /* individual muxer options */
3909
    while ((oformat = av_oformat_next(oformat))) {
3910
        if (oformat->priv_class) {
3911
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3912
            printf("\n");
3913
        }
3914
    }
3915

    
3916
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3917
}
3918

    
3919
static void opt_target(const char *arg)
3920
{
3921
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3922
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3923

    
3924
    if(!strncmp(arg, "pal-", 4)) {
3925
        norm = PAL;
3926
        arg += 4;
3927
    } else if(!strncmp(arg, "ntsc-", 5)) {
3928
        norm = NTSC;
3929
        arg += 5;
3930
    } else if(!strncmp(arg, "film-", 5)) {
3931
        norm = FILM;
3932
        arg += 5;
3933
    } else {
3934
        int fr;
3935
        /* Calculate FR via float to avoid int overflow */
3936
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3937
        if(fr == 25000) {
3938
            norm = PAL;
3939
        } else if((fr == 29970) || (fr == 23976)) {
3940
            norm = NTSC;
3941
        } else {
3942
            /* Try to determine PAL/NTSC by peeking in the input files */
3943
            if(nb_input_files) {
3944
                int i, j;
3945
                for(j = 0; j < nb_input_files; j++) {
3946
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3947
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3948
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3949
                            continue;
3950
                        fr = c->time_base.den * 1000 / c->time_base.num;
3951
                        if(fr == 25000) {
3952
                            norm = PAL;
3953
                            break;
3954
                        } else if((fr == 29970) || (fr == 23976)) {
3955
                            norm = NTSC;
3956
                            break;
3957
                        }
3958
                    }
3959
                    if(norm != UNKNOWN)
3960
                        break;
3961
                }
3962
            }
3963
        }
3964
        if(verbose && norm != UNKNOWN)
3965
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3966
    }
3967

    
3968
    if(norm == UNKNOWN) {
3969
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3970
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3971
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3972
        ffmpeg_exit(1);
3973
    }
3974

    
3975
    if(!strcmp(arg, "vcd")) {
3976

    
3977
        opt_video_codec("mpeg1video");
3978
        opt_audio_codec("mp2");
3979
        opt_format("vcd");
3980

    
3981
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3982
        opt_frame_rate(NULL, frame_rates[norm]);
3983
        opt_default("g", norm == PAL ? "15" : "18");
3984

    
3985
        opt_default("b", "1150000");
3986
        opt_default("maxrate", "1150000");
3987
        opt_default("minrate", "1150000");
3988
        opt_default("bufsize", "327680"); // 40*1024*8;
3989

    
3990
        opt_default("ab", "224000");
3991
        audio_sample_rate = 44100;
3992
        audio_channels = 2;
3993

    
3994
        opt_default("packetsize", "2324");
3995
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3996

    
3997
        /* We have to offset the PTS, so that it is consistent with the SCR.
3998
           SCR starts at 36000, but the first two packs contain only padding
3999
           and the first pack from the other stream, respectively, may also have
4000
           been written before.
4001
           So the real data starts at SCR 36000+3*1200. */
4002
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4003
    } else if(!strcmp(arg, "svcd")) {
4004

    
4005
        opt_video_codec("mpeg2video");
4006
        opt_audio_codec("mp2");
4007
        opt_format("svcd");
4008

    
4009
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4010
        opt_frame_rate(NULL, frame_rates[norm]);
4011
        opt_default("g", norm == PAL ? "15" : "18");
4012

    
4013
        opt_default("b", "2040000");
4014
        opt_default("maxrate", "2516000");
4015
        opt_default("minrate", "0"); //1145000;
4016
        opt_default("bufsize", "1835008"); //224*1024*8;
4017
        opt_default("flags", "+scan_offset");
4018

    
4019

    
4020
        opt_default("ab", "224000");
4021
        audio_sample_rate = 44100;
4022

    
4023
        opt_default("packetsize", "2324");
4024

    
4025
    } else if(!strcmp(arg, "dvd")) {
4026

    
4027
        opt_video_codec("mpeg2video");
4028
        opt_audio_codec("ac3");
4029
        opt_format("dvd");
4030

    
4031
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4032
        opt_frame_rate(NULL, frame_rates[norm]);
4033
        opt_default("g", norm == PAL ? "15" : "18");
4034

    
4035
        opt_default("b", "6000000");
4036
        opt_default("maxrate", "9000000");
4037
        opt_default("minrate", "0"); //1500000;
4038
        opt_default("bufsize", "1835008"); //224*1024*8;
4039

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

    
4043
        opt_default("ab", "448000");
4044
        audio_sample_rate = 48000;
4045

    
4046
    } else if(!strncmp(arg, "dv", 2)) {
4047

    
4048
        opt_format("dv");
4049

    
4050
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4051
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4052
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4053
        opt_frame_rate(NULL, frame_rates[norm]);
4054

    
4055
        audio_sample_rate = 48000;
4056
        audio_channels = 2;
4057

    
4058
    } else {
4059
        fprintf(stderr, "Unknown target: %s\n", arg);
4060
        ffmpeg_exit(1);
4061
    }
4062
}
4063

    
4064
static void opt_vstats_file (const char *arg)
4065
{
4066
    av_free (vstats_filename);
4067
    vstats_filename=av_strdup (arg);
4068
}
4069

    
4070
static void opt_vstats (void)
4071
{
4072
    char filename[40];
4073
    time_t today2 = time(NULL);
4074
    struct tm *today = localtime(&today2);
4075

    
4076
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4077
             today->tm_sec);
4078
    opt_vstats_file(filename);
4079
}
4080

    
4081
static int opt_bsf(const char *opt, const char *arg)
4082
{
4083
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4084
    AVBitStreamFilterContext **bsfp;
4085

    
4086
    if(!bsfc){
4087
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4088
        ffmpeg_exit(1);
4089
    }
4090

    
4091
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4092
          *opt == 'a' ? &audio_bitstream_filters :
4093
                        &subtitle_bitstream_filters;
4094
    while(*bsfp)
4095
        bsfp= &(*bsfp)->next;
4096

    
4097
    *bsfp= bsfc;
4098

    
4099
    return 0;
4100
}
4101

    
4102
static int opt_preset(const char *opt, const char *arg)
4103
{
4104
    FILE *f=NULL;
4105
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4106
    char *codec_name = *opt == 'v' ? video_codec_name :
4107
                       *opt == 'a' ? audio_codec_name :
4108
                                     subtitle_codec_name;
4109

    
4110
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4111
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4112
        ffmpeg_exit(1);
4113
    }
4114

    
4115
    while(!feof(f)){
4116
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4117
        if(line[0] == '#' && !e)
4118
            continue;
4119
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4120
        if(e){
4121
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4122
            ffmpeg_exit(1);
4123
        }
4124
        if(!strcmp(tmp, "acodec")){
4125
            opt_audio_codec(tmp2);
4126
        }else if(!strcmp(tmp, "vcodec")){
4127
            opt_video_codec(tmp2);
4128
        }else if(!strcmp(tmp, "scodec")){
4129
            opt_subtitle_codec(tmp2);
4130
        }else if(opt_default(tmp, tmp2) < 0){
4131
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4132
            ffmpeg_exit(1);
4133
        }
4134
    }
4135

    
4136
    fclose(f);
4137

    
4138
    return 0;
4139
}
4140

    
4141
static const OptionDef options[] = {
4142
    /* main options */
4143
#include "cmdutils_common_opts.h"
4144
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4145
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4146
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4147
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4148
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4149
      "outfile[,metadata]:infile[,metadata]" },
4150
    { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4151
      "outfile[,metadata]:infile[,metadata]" },
4152
    { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4153
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4154
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4155
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4156
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4157
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4158
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4159
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4160
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4161
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4162
      "add timings for benchmarking" },
4163
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4164
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4165
      "dump each input packet" },
4166
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4167
      "when dumping packets, also dump the payload" },
4168
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4169
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4170
    { "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)", "" },
4171
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4172
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4173
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4174
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4175
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4176
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4177
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4178
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4179
    { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4180
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4181
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4182
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4183
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4184
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4185

    
4186
    /* video options */
4187
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4188
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4189
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4190
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4191
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4192
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4193
    { "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" },
4194
    { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4195
    { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4196
    { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4197
    { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4198
    { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4199
    { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4200
    { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4201
    { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4202
    { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4203
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4204
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4205
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4206
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4207
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4208
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4209
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4210
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4211
      "use same video quality as source (implies VBR)" },
4212
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4213
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4214
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4215
      "deinterlace pictures" },
4216
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4217
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4218
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4219
#if CONFIG_AVFILTER
4220
    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4221
#endif
4222
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4223
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4224
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4225
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4226
    { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4227
    { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4228
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4229
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4230
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4231
    { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4232
    { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4233

    
4234
    /* audio options */
4235
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4236
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4237
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4238
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4239
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4240
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4241
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4242
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4243
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4244
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4245
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4246
    { "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" },
4247

    
4248
    /* subtitle options */
4249
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4250
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4251
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4252
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4253
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4254

    
4255
    /* grab options */
4256
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4257
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4258
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4259

    
4260
    /* muxer options */
4261
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4262
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4263

    
4264
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4265
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4266
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4267

    
4268
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4269
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4270
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4271
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4272

    
4273
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4274
    { NULL, },
4275
};
4276

    
4277
int main(int argc, char **argv)
4278
{
4279
    int64_t ti;
4280

    
4281
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4282

    
4283
    avcodec_register_all();
4284
#if CONFIG_AVDEVICE
4285
    avdevice_register_all();
4286
#endif
4287
#if CONFIG_AVFILTER
4288
    avfilter_register_all();
4289
#endif
4290
    av_register_all();
4291

    
4292
#if HAVE_ISATTY
4293
    if(isatty(STDIN_FILENO))
4294
        avio_set_interrupt_cb(decode_interrupt_cb);
4295
#endif
4296

    
4297
    init_opts();
4298

    
4299
    show_banner();
4300

    
4301
    /* parse options */
4302
    parse_options(argc, argv, options, opt_output_file);
4303

    
4304
    if(nb_output_files <= 0 && nb_input_files == 0) {
4305
        show_usage();
4306
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4307
        ffmpeg_exit(1);
4308
    }
4309

    
4310
    /* file converter / grab */
4311
    if (nb_output_files <= 0) {
4312
        fprintf(stderr, "At least one output file must be specified\n");
4313
        ffmpeg_exit(1);
4314
    }
4315

    
4316
    if (nb_input_files == 0) {
4317
        fprintf(stderr, "At least one input file must be specified\n");
4318
        ffmpeg_exit(1);
4319
    }
4320

    
4321
    ti = getutime();
4322
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4323
                  stream_maps, nb_stream_maps) < 0)
4324
        ffmpeg_exit(1);
4325
    ti = getutime() - ti;
4326
    if (do_benchmark) {
4327
        int maxrss = getmaxrss() / 1024;
4328
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4329
    }
4330

    
4331
    return ffmpeg_exit(0);
4332
}