Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 80c6e238

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
static const char *last_asked_format = NULL;
114
static AVFormatContext *input_files[MAX_FILES];
115
static int64_t input_files_ts_offset[MAX_FILES];
116
static double *input_files_ts_scale[MAX_FILES] = {NULL};
117
static AVCodec **input_codecs = NULL;
118
static int nb_input_files = 0;
119
static int nb_input_codecs = 0;
120
static int nb_input_files_ts_scale[MAX_FILES] = {0};
121

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

    
127
static AVStreamMap *stream_maps = NULL;
128
static int nb_stream_maps;
129

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

    
137
static AVChapterMap *chapter_maps = NULL;
138
static int nb_chapter_maps;
139

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

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

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

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

    
189
static float mux_preload= 0.5;
190
static float mux_max_delay= 0.7;
191

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

    
219
static int rate_emu = 0;
220

    
221
static int  video_channel = 0;
222
static char *video_standard;
223

    
224
static int audio_volume = 256;
225

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

    
241
static float dts_delta_threshold = 10;
242

    
243
static unsigned int sws_flags = SWS_BICUBIC;
244

    
245
static int64_t timer_start;
246

    
247
static uint8_t *audio_buf;
248
static uint8_t *audio_out;
249
static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
250

    
251
static short *samples;
252

    
253
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
254
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
255
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
256

    
257
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
258

    
259
struct AVInputStream;
260

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

    
282
    /* full frame size of first frame */
283
    int original_height;
284
    int original_width;
285

    
286
    /* forced key frames */
287
    int64_t *forced_kf_pts;
288
    int forced_kf_count;
289
    int forced_kf_index;
290

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

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

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

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

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

    
338
#if CONFIG_AVFILTER
339

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

    
350
    graph = avfilter_graph_alloc();
351

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

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

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

    
380
    if (vfilters) {
381
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
382
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
383

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

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

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

    
402
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
403
        return ret;
404

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

    
408
    return 0;
409
}
410
#endif /* CONFIG_AVFILTER */
411

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

    
417
static volatile int received_sigterm = 0;
418

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

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

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

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

    
450
static int ffmpeg_exit(int ret)
451
{
452
    int i;
453

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

    
467
    av_free(intra_matrix);
468
    av_free(inter_matrix);
469

    
470
    if (vstats_file)
471
        fclose(vstats_file);
472
    av_free(vstats_filename);
473

    
474
    av_free(streamid_map);
475
    av_free(input_codecs);
476
    av_free(output_codecs);
477
    av_free(stream_maps);
478
    av_free(meta_data_maps);
479

    
480
    av_free(video_codec_name);
481
    av_free(audio_codec_name);
482
    av_free(subtitle_codec_name);
483

    
484
    av_free(video_standard);
485

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

    
492
#if CONFIG_AVFILTER
493
    avfilter_uninit();
494
#endif
495

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

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

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

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

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

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

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

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

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

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

    
622
        s->nb_streams++;
623

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

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

    
648
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
649
            nopts = 1;
650

    
651
        new_output_stream(s, nb_output_files);
652
    }
653

    
654
    if (!nopts)
655
        s->timestamp = av_gettime();
656

    
657
    av_close_input_file(ic);
658
    return 0;
659
}
660

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

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

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

    
690
        bsfc= bsfc->next;
691
    }
692

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

    
700
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
701

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

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

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

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

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

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

    
742
    if (enc->channels != dec->channels)
743
        ost->audio_resample = 1;
744

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

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

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

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

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

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

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

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

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

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

    
884
        frame_bytes = enc->frame_size * osize * enc->channels;
885

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

    
890
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
891

    
892
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
893

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

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

    
915
        ost->sync_opts += size_out / (osize * enc->channels);
916

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

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

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

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

    
953
    dec = ist->st->codec;
954

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

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

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

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

    
980
    if (picture != picture2)
981
        *picture = *picture2;
982
    *bufp = buf;
983
}
984

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

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

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

    
1007
    enc = ost->st->codec;
1008

    
1009
    if (!subtitle_out) {
1010
        subtitle_out = av_malloc(subtitle_out_max_size);
1011
    }
1012

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

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

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

    
1051
static int bit_buffer_size= 1024*256;
1052
static uint8_t *bit_buffer= NULL;
1053

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

    
1065
    enc = ost->st->codec;
1066
    dec = ist->st->codec;
1067

    
1068
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1069

    
1070
    /* by default, we output a single frame */
1071
    nb_frames = 1;
1072

    
1073
    *frame_size = 0;
1074

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

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

    
1104
    formatted_picture = in_picture;
1105
    final_picture = formatted_picture;
1106
    padding_src = formatted_picture;
1107
    resampling_dst = &ost->pict_tmp;
1108

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1297

    
1298
    oc = output_files[0];
1299

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

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

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

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

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

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

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

    
1378
        fflush(stderr);
1379
    }
1380

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

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

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

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

    
1422
    if(ist->next_pts == AV_NOPTS_VALUE)
1423
        ist->next_pts= ist->pts;
1424

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1637
                        av_init_packet(&opkt);
1638

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

    
1642
                        /* no reencoding needed : output the packet directly */
1643
                        /* force the input stream PTS */
1644

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1791
    return 0;
1792
 fail_decode:
1793
    return -1;
1794
}
1795

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

    
1800
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1801
    printf("SDP:\n%s\n", sdp);
1802
    fflush(stdout);
1803
}
1804

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

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

    
1818

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

    
1824
        out_ch = av_mallocz(sizeof(AVChapter));
1825
        if (!out_ch)
1826
            return AVERROR(ENOMEM);
1827

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

    
1833
        if (metadata_chapters_autocopy)
1834
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1835

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2058
        codec = ost->st->codec;
2059
        icodec = ist->st->codec;
2060

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

    
2065
        ost->st->disposition = ist->st->disposition;
2066
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2067
        codec->chroma_sample_location = icodec->chroma_sample_location;
2068

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

    
2072
            if (extra_size > INT_MAX)
2073
                goto fail;
2074

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2333
        files[0] = output_files[out_file_index];
2334
        files[1] = input_files[in_file_index];
2335

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

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

    
2358
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2359
    }
2360

    
2361
    /* copy global metadata by default */
2362
    if (metadata_global_autocopy) {
2363

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

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

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

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

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

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

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

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

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

    
2444
    if (want_sdp) {
2445
        print_sdp(output_files, nb_output_files);
2446
    }
2447

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

    
2458
    timer_start = av_gettime();
2459

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

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

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

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

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

    
2537
        no_packet_count=0;
2538
        memset(no_packet, 0, sizeof(no_packet));
2539

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

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

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

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

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

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

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

    
2600
    discard_packet:
2601
        av_free_packet(&pkt);
2602

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

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

    
2615
    term_exit();
2616

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

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

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

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

    
2646
    /* finished ! */
2647
    ret = 0;
2648

    
2649
 fail:
2650
    av_freep(&bit_buffer);
2651
    av_free(file_table);
2652

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

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

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

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

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

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

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

    
2724
    opt_default(opt, arg);
2725

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

    
2729
    return 0;
2730
}
2731

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

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

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

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

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

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

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

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

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

    
2799
    av_metadata_set2(&metadata, arg, mid, 0);
2800

    
2801
    return 0;
2802
}
2803

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2906
    return 0;
2907
}
2908

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

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

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

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

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

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

    
2960
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2961
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2962

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

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

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

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

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

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

    
3000
    c->in_file = strtol(p, &p, 0);
3001
}
3002

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

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

    
3014
    if(stream >= MAX_STREAMS)
3015
        ffmpeg_exit(1);
3016

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

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

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

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

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

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

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

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

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

    
3095
    if (!strcmp(filename, "-"))
3096
        filename = "pipe:";
3097

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

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

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

    
3121
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3122

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

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

    
3164
    ic->loop_input = loop_input;
3165

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

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

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

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

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

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

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

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

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

    
3275
    nb_input_files++;
3276

    
3277
    video_channel = 0;
3278

    
3279
    av_freep(&video_codec_name);
3280
    av_freep(&audio_codec_name);
3281
    av_freep(&subtitle_codec_name);
3282
}
3283

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

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

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

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

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

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

    
3353
    st->codec->thread_count= thread_count;
3354

    
3355
    video_enc = st->codec;
3356

    
3357
    if(video_codec_tag)
3358
        video_enc->codec_tag= video_codec_tag;
3359

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

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

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

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

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

    
3394
        choose_pixel_fmt(st, codec);
3395

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

    
3404
        if(intra_matrix)
3405
            video_enc->intra_matrix = intra_matrix;
3406
        if(inter_matrix)
3407
            video_enc->inter_matrix = inter_matrix;
3408

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

    
3439
        if (do_psnr)
3440
            video_enc->flags|= CODEC_FLAG_PSNR;
3441

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

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

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

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

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

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

    
3495
    avcodec_get_context_defaults3(st->codec, codec);
3496

    
3497
    ost->bitstream_filters = audio_bitstream_filters;
3498
    audio_bitstream_filters= NULL;
3499

    
3500
    st->codec->thread_count= thread_count;
3501

    
3502
    audio_enc = st->codec;
3503
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3504

    
3505
    if(audio_codec_tag)
3506
        audio_enc->codec_tag= audio_codec_tag;
3507

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

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

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

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

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

    
3573
    ost->bitstream_filters = subtitle_bitstream_filters;
3574
    subtitle_bitstream_filters= NULL;
3575

    
3576
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3577

    
3578
    if(subtitle_codec_tag)
3579
        subtitle_enc->codec_tag= subtitle_codec_tag;
3580

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

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

    
3597
    subtitle_disable = 0;
3598
    av_freep(&subtitle_codec_name);
3599
    subtitle_stream_copy = 0;
3600
}
3601

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

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

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

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

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

    
3650
    if (!strcmp(filename, "-"))
3651
        filename = "pipe:";
3652

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

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

    
3675
    oc->oformat = file_oformat;
3676
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3677

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

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

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

    
3710
        if (use_video)    new_video_stream(oc, nb_output_files);
3711
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3712
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3713

    
3714
        oc->timestamp = recording_timestamp;
3715

    
3716
        av_metadata_copy(&oc->metadata, metadata, 0);
3717
        av_metadata_free(&metadata);
3718
    }
3719

    
3720
    output_files[nb_output_files++] = oc;
3721

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

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

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

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

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

    
3771
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3772

    
3773
    av_freep(&forced_key_frames);
3774
}
3775

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3914
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3915
}
3916

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

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

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

    
3973
    if(!strcmp(arg, "vcd")) {
3974

    
3975
        opt_video_codec("mpeg1video");
3976
        opt_audio_codec("mp2");
3977
        opt_format("vcd");
3978

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

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

    
3988
        opt_default("ab", "224000");
3989
        audio_sample_rate = 44100;
3990
        audio_channels = 2;
3991

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

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

    
4003
        opt_video_codec("mpeg2video");
4004
        opt_audio_codec("mp2");
4005
        opt_format("svcd");
4006

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

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

    
4017

    
4018
        opt_default("ab", "224000");
4019
        audio_sample_rate = 44100;
4020

    
4021
        opt_default("packetsize", "2324");
4022

    
4023
    } else if(!strcmp(arg, "dvd")) {
4024

    
4025
        opt_video_codec("mpeg2video");
4026
        opt_audio_codec("ac3");
4027
        opt_format("dvd");
4028

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

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

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

    
4041
        opt_default("ab", "448000");
4042
        audio_sample_rate = 48000;
4043

    
4044
    } else if(!strncmp(arg, "dv", 2)) {
4045

    
4046
        opt_format("dv");
4047

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

    
4053
        audio_sample_rate = 48000;
4054
        audio_channels = 2;
4055

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

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

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

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

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

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

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

    
4095
    *bsfp= bsfc;
4096

    
4097
    return 0;
4098
}
4099

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

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

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

    
4134
    fclose(f);
4135

    
4136
    return 0;
4137
}
4138

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

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

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

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

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

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

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

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

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

    
4275
int main(int argc, char **argv)
4276
{
4277
    int64_t ti;
4278

    
4279
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4280

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

    
4290
#if HAVE_ISATTY
4291
    if(isatty(STDIN_FILENO))
4292
        avio_set_interrupt_cb(decode_interrupt_cb);
4293
#endif
4294

    
4295
    init_opts();
4296

    
4297
    show_banner();
4298

    
4299
    /* parse options */
4300
    parse_options(argc, argv, options, opt_output_file);
4301

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

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

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

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

    
4329
    return ffmpeg_exit(0);
4330
}