Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 4ffc79e7

History | View | Annotate | Download (159 KB)

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

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

    
25
#include "config.h"
26
#include <ctype.h>
27
#include <string.h>
28
#include <math.h>
29
#include <stdlib.h>
30
#include <errno.h>
31
#include <signal.h>
32
#include <limits.h>
33
#include <unistd.h>
34
#include "libavformat/avformat.h"
35
#include "libavdevice/avdevice.h"
36
#include "libswscale/swscale.h"
37
#include "libavcodec/opt.h"
38
#include "libavcodec/audioconvert.h"
39
#include "libavutil/audioconvert.h"
40
#include "libavutil/parseutils.h"
41
#include "libavutil/samplefmt.h"
42
#include "libavutil/colorspace.h"
43
#include "libavutil/fifo.h"
44
#include "libavutil/intreadwrite.h"
45
#include "libavutil/pixdesc.h"
46
#include "libavutil/avstring.h"
47
#include "libavutil/libm.h"
48
#include "libavformat/os_support.h"
49

    
50
#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
#else
171
static unsigned int sws_flags = SWS_BICUBIC;
172
#endif
173

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

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

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

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

    
220
static int rate_emu = 0;
221

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

    
225
static int audio_volume = 256;
226

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

    
242
static float dts_delta_threshold = 10;
243

    
244
static int64_t timer_start;
245

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

    
250
static short *samples;
251

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

    
256
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
257

    
258
struct AVInputStream;
259

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

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

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

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

    
301
#if CONFIG_AVFILTER
302
    AVFilterContext *output_video_filter;
303
    AVFilterContext *input_video_filter;
304
    AVFilterBufferRef *picref;
305
    char *avfilter;
306
    AVFilterGraph *graph;
307
#endif
308
} AVOutputStream;
309

    
310
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
311
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
312

    
313
typedef struct AVInputStream {
314
    int file_index;
315
    int index;
316
    AVStream *st;
317
    int discard;             /* true if stream data should be discarded */
318
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
319
    int64_t sample_index;      /* current sample */
320

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

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

    
341
#if CONFIG_AVFILTER
342

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

    
354
    ost->graph = avfilter_graph_alloc();
355

    
356
    if (ist->st->sample_aspect_ratio.num){
357
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
358
    }else
359
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
360

    
361
    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
362
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
363
             sample_aspect_ratio.num, sample_aspect_ratio.den);
364

    
365
    ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
366
                                       "src", args, NULL, ost->graph);
367
    if (ret < 0)
368
        return ret;
369
    ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
370
                                       "out", NULL, &ffsink_ctx, ost->graph);
371
    if (ret < 0)
372
        return ret;
373
    last_filter = ost->input_video_filter;
374

    
375
    if (codec->width  != icodec->width || codec->height != icodec->height) {
376
        snprintf(args, 255, "%d:%d:flags=0x%X",
377
                 codec->width,
378
                 codec->height,
379
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
380
        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
381
                                                NULL, args, NULL, ost->graph)) < 0)
382
            return ret;
383
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
384
            return ret;
385
        last_filter = filter;
386
    }
387

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

    
391
    if (ost->avfilter) {
392
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
393
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
394

    
395
        outputs->name    = av_strdup("in");
396
        outputs->filter_ctx = last_filter;
397
        outputs->pad_idx = 0;
398
        outputs->next    = NULL;
399

    
400
        inputs->name    = av_strdup("out");
401
        inputs->filter_ctx = ost->output_video_filter;
402
        inputs->pad_idx = 0;
403
        inputs->next    = NULL;
404

    
405
        if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
406
            return ret;
407
        av_freep(&ost->avfilter);
408
    } else {
409
        if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
410
            return ret;
411
    }
412

    
413
    if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
414
        return ret;
415

    
416
    codec->width  = ost->output_video_filter->inputs[0]->w;
417
    codec->height = ost->output_video_filter->inputs[0]->h;
418
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
419
        ost->output_video_filter->inputs[0]->sample_aspect_ratio;
420

    
421
    return 0;
422
}
423
#endif /* CONFIG_AVFILTER */
424

    
425
static void term_exit(void)
426
{
427
    av_log(NULL, AV_LOG_QUIET, "");
428
}
429

    
430
static volatile int received_sigterm = 0;
431

    
432
static void
433
sigterm_handler(int sig)
434
{
435
    received_sigterm = sig;
436
    q_pressed++;
437
    term_exit();
438
}
439

    
440
static void term_init(void)
441
{
442
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
443
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
444
#ifdef SIGXCPU
445
    signal(SIGXCPU, sigterm_handler);
446
#endif
447
}
448

    
449
/* read a key without blocking */
450
static int read_key(void)
451
{
452
#if HAVE_KBHIT
453
    if(kbhit())
454
        return(getch());
455
#endif
456
    return -1;
457
}
458

    
459
static int decode_interrupt_cb(void)
460
{
461
    q_pressed += read_key() == 'q';
462
    return q_pressed > 1;
463
}
464

    
465
static int ffmpeg_exit(int ret)
466
{
467
    int i;
468

    
469
    /* close files */
470
    for(i=0;i<nb_output_files;i++) {
471
        AVFormatContext *s = output_files[i];
472
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
473
            avio_close(s->pb);
474
        avformat_free_context(s);
475
        av_free(output_streams_for_file[i]);
476
    }
477
    for(i=0;i<nb_input_files;i++) {
478
        av_close_input_file(input_files[i]);
479
        av_free(input_files_ts_scale[i]);
480
    }
481

    
482
    av_free(intra_matrix);
483
    av_free(inter_matrix);
484

    
485
    if (vstats_file)
486
        fclose(vstats_file);
487
    av_free(vstats_filename);
488

    
489
    av_free(streamid_map);
490
    av_free(input_codecs);
491
    av_free(output_codecs);
492
    av_free(stream_maps);
493
    av_free(meta_data_maps);
494

    
495
    av_free(video_codec_name);
496
    av_free(audio_codec_name);
497
    av_free(subtitle_codec_name);
498

    
499
    av_free(video_standard);
500

    
501
    uninit_opts();
502
    av_free(audio_buf);
503
    av_free(audio_out);
504
    allocated_audio_buf_size= allocated_audio_out_size= 0;
505
    av_free(samples);
506

    
507
#if CONFIG_AVFILTER
508
    avfilter_uninit();
509
#endif
510

    
511
    if (received_sigterm) {
512
        fprintf(stderr,
513
            "Received signal %d: terminating.\n",
514
            (int) received_sigterm);
515
        exit (255);
516
    }
517

    
518
    exit(ret); /* not all OS-es handle main() return value */
519
    return ret;
520
}
521

    
522
/* similar to ff_dynarray_add() and av_fast_realloc() */
523
static void *grow_array(void *array, int elem_size, int *size, int new_size)
524
{
525
    if (new_size >= INT_MAX / elem_size) {
526
        fprintf(stderr, "Array too big.\n");
527
        ffmpeg_exit(1);
528
    }
529
    if (*size < new_size) {
530
        uint8_t *tmp = av_realloc(array, new_size*elem_size);
531
        if (!tmp) {
532
            fprintf(stderr, "Could not alloc buffer.\n");
533
            ffmpeg_exit(1);
534
        }
535
        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
536
        *size = new_size;
537
        return tmp;
538
    }
539
    return array;
540
}
541

    
542
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
543
{
544
    if(codec && codec->sample_fmts){
545
        const enum AVSampleFormat *p= codec->sample_fmts;
546
        for(; *p!=-1; p++){
547
            if(*p == st->codec->sample_fmt)
548
                break;
549
        }
550
        if (*p == -1) {
551
            av_log(NULL, AV_LOG_WARNING,
552
                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
553
                   av_get_sample_fmt_name(st->codec->sample_fmt),
554
                   codec->name,
555
                   av_get_sample_fmt_name(codec->sample_fmts[0]));
556
            st->codec->sample_fmt = codec->sample_fmts[0];
557
        }
558
    }
559
}
560

    
561
static void choose_sample_rate(AVStream *st, AVCodec *codec)
562
{
563
    if(codec && codec->supported_samplerates){
564
        const int *p= codec->supported_samplerates;
565
        int best=0;
566
        int best_dist=INT_MAX;
567
        for(; *p; p++){
568
            int dist= abs(st->codec->sample_rate - *p);
569
            if(dist < best_dist){
570
                best_dist= dist;
571
                best= *p;
572
            }
573
        }
574
        if(best_dist){
575
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
576
        }
577
        st->codec->sample_rate= best;
578
    }
579
}
580

    
581
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
582
{
583
    if(codec && codec->pix_fmts){
584
        const enum PixelFormat *p= codec->pix_fmts;
585
        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
586
            if(st->codec->codec_id==CODEC_ID_MJPEG){
587
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
588
            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
589
                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};
590
            }
591
        }
592
        for(; *p!=-1; p++){
593
            if(*p == st->codec->pix_fmt)
594
                break;
595
        }
596
        if(*p == -1)
597
            st->codec->pix_fmt = codec->pix_fmts[0];
598
    }
599
}
600

    
601
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
602
{
603
    int idx = oc->nb_streams - 1;
604
    AVOutputStream *ost;
605

    
606
    output_streams_for_file[file_idx] =
607
        grow_array(output_streams_for_file[file_idx],
608
                   sizeof(*output_streams_for_file[file_idx]),
609
                   &nb_output_streams_for_file[file_idx],
610
                   oc->nb_streams);
611
    ost = output_streams_for_file[file_idx][idx] =
612
        av_mallocz(sizeof(AVOutputStream));
613
    if (!ost) {
614
        fprintf(stderr, "Could not alloc output stream\n");
615
        ffmpeg_exit(1);
616
    }
617
    ost->file_index = file_idx;
618
    ost->index = idx;
619
    return ost;
620
}
621

    
622
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
623
{
624
    int i, err;
625
    AVFormatContext *ic;
626
    int nopts = 0;
627

    
628
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
629
    if (err < 0)
630
        return err;
631
    /* copy stream format */
632
    s->nb_streams = 0;
633
    for(i=0;i<ic->nb_streams;i++) {
634
        AVStream *st;
635
        AVCodec *codec;
636

    
637
        s->nb_streams++;
638

    
639
        // FIXME: a more elegant solution is needed
640
        st = av_mallocz(sizeof(AVStream));
641
        memcpy(st, ic->streams[i], sizeof(AVStream));
642
        st->codec = avcodec_alloc_context();
643
        if (!st->codec) {
644
            print_error(filename, AVERROR(ENOMEM));
645
            ffmpeg_exit(1);
646
        }
647
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
648
        s->streams[i] = st;
649

    
650
        codec = avcodec_find_encoder(st->codec->codec_id);
651
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
652
            if (audio_stream_copy) {
653
                st->stream_copy = 1;
654
            } else
655
                choose_sample_fmt(st, codec);
656
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
657
            if (video_stream_copy) {
658
                st->stream_copy = 1;
659
            } else
660
                choose_pixel_fmt(st, codec);
661
        }
662

    
663
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
664
            nopts = 1;
665

    
666
        new_output_stream(s, nb_output_files);
667
    }
668

    
669
    if (!nopts)
670
        s->timestamp = av_gettime();
671

    
672
    av_close_input_file(ic);
673
    return 0;
674
}
675

    
676
static double
677
get_sync_ipts(const AVOutputStream *ost)
678
{
679
    const AVInputStream *ist = ost->sync_ist;
680
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
681
}
682

    
683
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
684
    int ret;
685

    
686
    while(bsfc){
687
        AVPacket new_pkt= *pkt;
688
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
689
                                          &new_pkt.data, &new_pkt.size,
690
                                          pkt->data, pkt->size,
691
                                          pkt->flags & AV_PKT_FLAG_KEY);
692
        if(a>0){
693
            av_free_packet(pkt);
694
            new_pkt.destruct= av_destruct_packet;
695
        } else if(a<0){
696
            fprintf(stderr, "%s failed for stream %d, codec %s",
697
                    bsfc->filter->name, pkt->stream_index,
698
                    avctx->codec ? avctx->codec->name : "copy");
699
            print_error("", a);
700
            if (exit_on_error)
701
                ffmpeg_exit(1);
702
        }
703
        *pkt= new_pkt;
704

    
705
        bsfc= bsfc->next;
706
    }
707

    
708
    ret= av_interleaved_write_frame(s, pkt);
709
    if(ret < 0){
710
        print_error("av_interleaved_write_frame()", ret);
711
        ffmpeg_exit(1);
712
    }
713
}
714

    
715
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
716

    
717
static void do_audio_out(AVFormatContext *s,
718
                         AVOutputStream *ost,
719
                         AVInputStream *ist,
720
                         unsigned char *buf, int size)
721
{
722
    uint8_t *buftmp;
723
    int64_t audio_out_size, audio_buf_size;
724
    int64_t allocated_for_size= size;
725

    
726
    int size_out, frame_bytes, ret, resample_changed;
727
    AVCodecContext *enc= ost->st->codec;
728
    AVCodecContext *dec= ist->st->codec;
729
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
730
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
731
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
732

    
733
need_realloc:
734
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
735
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
736
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
737
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
738
    audio_buf_size*= osize*enc->channels;
739

    
740
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
741
    if(coded_bps > 8*osize)
742
        audio_out_size= audio_out_size * coded_bps / (8*osize);
743
    audio_out_size += FF_MIN_BUFFER_SIZE;
744

    
745
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
746
        fprintf(stderr, "Buffer sizes too large\n");
747
        ffmpeg_exit(1);
748
    }
749

    
750
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
751
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
752
    if (!audio_buf || !audio_out){
753
        fprintf(stderr, "Out of memory in do_audio_out\n");
754
        ffmpeg_exit(1);
755
    }
756

    
757
    if (enc->channels != dec->channels)
758
        ost->audio_resample = 1;
759

    
760
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
761
                       ost->resample_channels    != dec->channels   ||
762
                       ost->resample_sample_rate != dec->sample_rate;
763

    
764
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
765
        if (resample_changed) {
766
            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",
767
                   ist->file_index, ist->index,
768
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
769
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
770
            ost->resample_sample_fmt  = dec->sample_fmt;
771
            ost->resample_channels    = dec->channels;
772
            ost->resample_sample_rate = dec->sample_rate;
773
            if (ost->resample)
774
                audio_resample_close(ost->resample);
775
        }
776
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
777
        if (audio_sync_method <= 1 &&
778
            ost->resample_sample_fmt  == enc->sample_fmt &&
779
            ost->resample_channels    == enc->channels   &&
780
            ost->resample_sample_rate == enc->sample_rate) {
781
            ost->resample = NULL;
782
            ost->audio_resample = 0;
783
        } else {
784
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
785
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
786
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
787
                                                   enc->sample_rate, dec->sample_rate,
788
                                                   enc->sample_fmt,  dec->sample_fmt,
789
                                                   16, 10, 0, 0.8);
790
            if (!ost->resample) {
791
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
792
                        dec->channels, dec->sample_rate,
793
                        enc->channels, enc->sample_rate);
794
                ffmpeg_exit(1);
795
            }
796
        }
797
    }
798

    
799
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
800
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
801
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
802
        if (ost->reformat_ctx)
803
            av_audio_convert_free(ost->reformat_ctx);
804
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
805
                                                   dec->sample_fmt, 1, NULL, 0);
806
        if (!ost->reformat_ctx) {
807
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
808
                av_get_sample_fmt_name(dec->sample_fmt),
809
                av_get_sample_fmt_name(enc->sample_fmt));
810
            ffmpeg_exit(1);
811
        }
812
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
813
    }
814

    
815
    if(audio_sync_method){
816
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
817
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
818
        double idelta= delta*dec->sample_rate / enc->sample_rate;
819
        int byte_delta= ((int)idelta)*2*dec->channels;
820

    
821
        //FIXME resample delay
822
        if(fabs(delta) > 50){
823
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
824
                if(byte_delta < 0){
825
                    byte_delta= FFMAX(byte_delta, -size);
826
                    size += byte_delta;
827
                    buf  -= byte_delta;
828
                    if(verbose > 2)
829
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
830
                    if(!size)
831
                        return;
832
                    ist->is_start=0;
833
                }else{
834
                    static uint8_t *input_tmp= NULL;
835
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
836

    
837
                    if(byte_delta > allocated_for_size - size){
838
                        allocated_for_size= byte_delta + (int64_t)size;
839
                        goto need_realloc;
840
                    }
841
                    ist->is_start=0;
842

    
843
                    memset(input_tmp, 0, byte_delta);
844
                    memcpy(input_tmp + byte_delta, buf, size);
845
                    buf= input_tmp;
846
                    size += byte_delta;
847
                    if(verbose > 2)
848
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
849
                }
850
            }else if(audio_sync_method>1){
851
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
852
                av_assert0(ost->audio_resample);
853
                if(verbose > 2)
854
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
855
//                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));
856
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
857
            }
858
        }
859
    }else
860
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
861
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
862

    
863
    if (ost->audio_resample) {
864
        buftmp = audio_buf;
865
        size_out = audio_resample(ost->resample,
866
                                  (short *)buftmp, (short *)buf,
867
                                  size / (dec->channels * isize));
868
        size_out = size_out * enc->channels * osize;
869
    } else {
870
        buftmp = buf;
871
        size_out = size;
872
    }
873

    
874
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
875
        const void *ibuf[6]= {buftmp};
876
        void *obuf[6]= {audio_buf};
877
        int istride[6]= {isize};
878
        int ostride[6]= {osize};
879
        int len= size_out/istride[0];
880
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
881
            printf("av_audio_convert() failed\n");
882
            if (exit_on_error)
883
                ffmpeg_exit(1);
884
            return;
885
        }
886
        buftmp = audio_buf;
887
        size_out = len*osize;
888
    }
889

    
890
    /* now encode as many frames as possible */
891
    if (enc->frame_size > 1) {
892
        /* output resampled raw samples */
893
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
894
            fprintf(stderr, "av_fifo_realloc2() failed\n");
895
            ffmpeg_exit(1);
896
        }
897
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
898

    
899
        frame_bytes = enc->frame_size * osize * enc->channels;
900

    
901
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
902
            AVPacket pkt;
903
            av_init_packet(&pkt);
904

    
905
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
906

    
907
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
908

    
909
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
910
                                       (short *)audio_buf);
911
            if (ret < 0) {
912
                fprintf(stderr, "Audio encoding failed\n");
913
                ffmpeg_exit(1);
914
            }
915
            audio_size += ret;
916
            pkt.stream_index= ost->index;
917
            pkt.data= audio_out;
918
            pkt.size= ret;
919
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
920
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
921
            pkt.flags |= AV_PKT_FLAG_KEY;
922
            write_frame(s, &pkt, enc, ost->bitstream_filters);
923

    
924
            ost->sync_opts += enc->frame_size;
925
        }
926
    } else {
927
        AVPacket pkt;
928
        av_init_packet(&pkt);
929

    
930
        ost->sync_opts += size_out / (osize * enc->channels);
931

    
932
        /* output a pcm frame */
933
        /* determine the size of the coded buffer */
934
        size_out /= osize;
935
        if (coded_bps)
936
            size_out = size_out*coded_bps/8;
937

    
938
        if(size_out > audio_out_size){
939
            fprintf(stderr, "Internal error, buffer size too small\n");
940
            ffmpeg_exit(1);
941
        }
942

    
943
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
944
        ret = avcodec_encode_audio(enc, audio_out, size_out,
945
                                   (short *)buftmp);
946
        if (ret < 0) {
947
            fprintf(stderr, "Audio encoding failed\n");
948
            ffmpeg_exit(1);
949
        }
950
        audio_size += ret;
951
        pkt.stream_index= ost->index;
952
        pkt.data= audio_out;
953
        pkt.size= ret;
954
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
955
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
956
        pkt.flags |= AV_PKT_FLAG_KEY;
957
        write_frame(s, &pkt, enc, ost->bitstream_filters);
958
    }
959
}
960

    
961
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
962
{
963
    AVCodecContext *dec;
964
    AVPicture *picture2;
965
    AVPicture picture_tmp;
966
    uint8_t *buf = 0;
967

    
968
    dec = ist->st->codec;
969

    
970
    /* deinterlace : must be done before any resize */
971
    if (do_deinterlace) {
972
        int size;
973

    
974
        /* create temporary picture */
975
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
976
        buf = av_malloc(size);
977
        if (!buf)
978
            return;
979

    
980
        picture2 = &picture_tmp;
981
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
982

    
983
        if(avpicture_deinterlace(picture2, picture,
984
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
985
            /* if error, do not deinterlace */
986
            fprintf(stderr, "Deinterlacing failed\n");
987
            av_free(buf);
988
            buf = NULL;
989
            picture2 = picture;
990
        }
991
    } else {
992
        picture2 = picture;
993
    }
994

    
995
    if (picture != picture2)
996
        *picture = *picture2;
997
    *bufp = buf;
998
}
999

    
1000
/* we begin to correct av delay at this threshold */
1001
#define AV_DELAY_MAX 0.100
1002

    
1003
static void do_subtitle_out(AVFormatContext *s,
1004
                            AVOutputStream *ost,
1005
                            AVInputStream *ist,
1006
                            AVSubtitle *sub,
1007
                            int64_t pts)
1008
{
1009
    static uint8_t *subtitle_out = NULL;
1010
    int subtitle_out_max_size = 1024 * 1024;
1011
    int subtitle_out_size, nb, i;
1012
    AVCodecContext *enc;
1013
    AVPacket pkt;
1014

    
1015
    if (pts == AV_NOPTS_VALUE) {
1016
        fprintf(stderr, "Subtitle packets must have a pts\n");
1017
        if (exit_on_error)
1018
            ffmpeg_exit(1);
1019
        return;
1020
    }
1021

    
1022
    enc = ost->st->codec;
1023

    
1024
    if (!subtitle_out) {
1025
        subtitle_out = av_malloc(subtitle_out_max_size);
1026
    }
1027

    
1028
    /* Note: DVB subtitle need one packet to draw them and one other
1029
       packet to clear them */
1030
    /* XXX: signal it in the codec context ? */
1031
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1032
        nb = 2;
1033
    else
1034
        nb = 1;
1035

    
1036
    for(i = 0; i < nb; i++) {
1037
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1038
        // start_display_time is required to be 0
1039
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1040
        sub->end_display_time -= sub->start_display_time;
1041
        sub->start_display_time = 0;
1042
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1043
                                                    subtitle_out_max_size, sub);
1044
        if (subtitle_out_size < 0) {
1045
            fprintf(stderr, "Subtitle encoding failed\n");
1046
            ffmpeg_exit(1);
1047
        }
1048

    
1049
        av_init_packet(&pkt);
1050
        pkt.stream_index = ost->index;
1051
        pkt.data = subtitle_out;
1052
        pkt.size = subtitle_out_size;
1053
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1054
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1055
            /* XXX: the pts correction is handled here. Maybe handling
1056
               it in the codec would be better */
1057
            if (i == 0)
1058
                pkt.pts += 90 * sub->start_display_time;
1059
            else
1060
                pkt.pts += 90 * sub->end_display_time;
1061
        }
1062
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1063
    }
1064
}
1065

    
1066
static int bit_buffer_size= 1024*256;
1067
static uint8_t *bit_buffer= NULL;
1068

    
1069
static void do_video_out(AVFormatContext *s,
1070
                         AVOutputStream *ost,
1071
                         AVInputStream *ist,
1072
                         AVFrame *in_picture,
1073
                         int *frame_size)
1074
{
1075
    int nb_frames, i, ret;
1076
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1077
    AVCodecContext *enc, *dec;
1078
    double sync_ipts;
1079

    
1080
    enc = ost->st->codec;
1081
    dec = ist->st->codec;
1082

    
1083
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1084

    
1085
    /* by default, we output a single frame */
1086
    nb_frames = 1;
1087

    
1088
    *frame_size = 0;
1089

    
1090
    if(video_sync_method){
1091
        double vdelta = sync_ipts - ost->sync_opts;
1092
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1093
        if (vdelta < -1.1)
1094
            nb_frames = 0;
1095
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1096
            if(vdelta<=-0.6){
1097
                nb_frames=0;
1098
            }else if(vdelta>0.6)
1099
                ost->sync_opts= lrintf(sync_ipts);
1100
        }else if (vdelta > 1.1)
1101
            nb_frames = lrintf(vdelta);
1102
//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);
1103
        if (nb_frames == 0){
1104
            ++nb_frames_drop;
1105
            if (verbose>2)
1106
                fprintf(stderr, "*** drop!\n");
1107
        }else if (nb_frames > 1) {
1108
            nb_frames_dup += nb_frames - 1;
1109
            if (verbose>2)
1110
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1111
        }
1112
    }else
1113
        ost->sync_opts= lrintf(sync_ipts);
1114

    
1115
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1116
    if (nb_frames <= 0)
1117
        return;
1118

    
1119
    formatted_picture = in_picture;
1120
    final_picture = formatted_picture;
1121
    padding_src = formatted_picture;
1122
    resampling_dst = &ost->pict_tmp;
1123

    
1124
    if (   ost->resample_height != ist->st->codec->height
1125
        || ost->resample_width  != ist->st->codec->width
1126
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1127

    
1128
        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));
1129
        if(!ost->video_resample)
1130
            ffmpeg_exit(1);
1131
    }
1132

    
1133
#if !CONFIG_AVFILTER
1134
    if (ost->video_resample) {
1135
        padding_src = NULL;
1136
        final_picture = &ost->pict_tmp;
1137
        if(  ost->resample_height != ist->st->codec->height
1138
          || ost->resample_width  != ist->st->codec->width
1139
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1140

    
1141
            /* initialize a new scaler context */
1142
            sws_freeContext(ost->img_resample_ctx);
1143
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1144
            ost->img_resample_ctx = sws_getContext(
1145
                ist->st->codec->width,
1146
                ist->st->codec->height,
1147
                ist->st->codec->pix_fmt,
1148
                ost->st->codec->width,
1149
                ost->st->codec->height,
1150
                ost->st->codec->pix_fmt,
1151
                sws_flags, NULL, NULL, NULL);
1152
            if (ost->img_resample_ctx == NULL) {
1153
                fprintf(stderr, "Cannot get resampling context\n");
1154
                ffmpeg_exit(1);
1155
            }
1156
        }
1157
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1158
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1159
    }
1160
#endif
1161

    
1162
    /* duplicates frame if needed */
1163
    for(i=0;i<nb_frames;i++) {
1164
        AVPacket pkt;
1165
        av_init_packet(&pkt);
1166
        pkt.stream_index= ost->index;
1167

    
1168
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1169
            /* raw pictures are written as AVPicture structure to
1170
               avoid any copies. We support temorarily the older
1171
               method. */
1172
            AVFrame* old_frame = enc->coded_frame;
1173
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1174
            pkt.data= (uint8_t *)final_picture;
1175
            pkt.size=  sizeof(AVPicture);
1176
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1177
            pkt.flags |= AV_PKT_FLAG_KEY;
1178

    
1179
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1180
            enc->coded_frame = old_frame;
1181
        } else {
1182
            AVFrame big_picture;
1183

    
1184
            big_picture= *final_picture;
1185
            /* better than nothing: use input picture interlaced
1186
               settings */
1187
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1188
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1189
                if(top_field_first == -1)
1190
                    big_picture.top_field_first = in_picture->top_field_first;
1191
                else
1192
                    big_picture.top_field_first = top_field_first;
1193
            }
1194

    
1195
            /* handles sameq here. This is not correct because it may
1196
               not be a global option */
1197
            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1198
            if(!me_threshold)
1199
                big_picture.pict_type = 0;
1200
//            big_picture.pts = AV_NOPTS_VALUE;
1201
            big_picture.pts= ost->sync_opts;
1202
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1203
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1204
            if (ost->forced_kf_index < ost->forced_kf_count &&
1205
                big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1206
                big_picture.pict_type = FF_I_TYPE;
1207
                ost->forced_kf_index++;
1208
            }
1209
            ret = avcodec_encode_video(enc,
1210
                                       bit_buffer, bit_buffer_size,
1211
                                       &big_picture);
1212
            if (ret < 0) {
1213
                fprintf(stderr, "Video encoding failed\n");
1214
                ffmpeg_exit(1);
1215
            }
1216

    
1217
            if(ret>0){
1218
                pkt.data= bit_buffer;
1219
                pkt.size= ret;
1220
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1221
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1222
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1223
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1224
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1225

    
1226
                if(enc->coded_frame->key_frame)
1227
                    pkt.flags |= AV_PKT_FLAG_KEY;
1228
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1229
                *frame_size = ret;
1230
                video_size += ret;
1231
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1232
                //        enc->frame_number-1, ret, enc->pict_type);
1233
                /* if two pass, output log */
1234
                if (ost->logfile && enc->stats_out) {
1235
                    fprintf(ost->logfile, "%s", enc->stats_out);
1236
                }
1237
            }
1238
        }
1239
        ost->sync_opts++;
1240
        ost->frame_number++;
1241
    }
1242
}
1243

    
1244
static double psnr(double d){
1245
    return -10.0*log(d)/log(10.0);
1246
}
1247

    
1248
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1249
                           int frame_size)
1250
{
1251
    AVCodecContext *enc;
1252
    int frame_number;
1253
    double ti1, bitrate, avg_bitrate;
1254

    
1255
    /* this is executed just the first time do_video_stats is called */
1256
    if (!vstats_file) {
1257
        vstats_file = fopen(vstats_filename, "w");
1258
        if (!vstats_file) {
1259
            perror("fopen");
1260
            ffmpeg_exit(1);
1261
        }
1262
    }
1263

    
1264
    enc = ost->st->codec;
1265
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1266
        frame_number = ost->frame_number;
1267
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1268
        if (enc->flags&CODEC_FLAG_PSNR)
1269
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1270

    
1271
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1272
        /* compute pts value */
1273
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1274
        if (ti1 < 0.01)
1275
            ti1 = 0.01;
1276

    
1277
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1278
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1279
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1280
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1281
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1282
    }
1283
}
1284

    
1285
static void print_report(AVFormatContext **output_files,
1286
                         AVOutputStream **ost_table, int nb_ostreams,
1287
                         int is_last_report)
1288
{
1289
    char buf[1024];
1290
    AVOutputStream *ost;
1291
    AVFormatContext *oc;
1292
    int64_t total_size;
1293
    AVCodecContext *enc;
1294
    int frame_number, vid, i;
1295
    double bitrate, ti1, pts;
1296
    static int64_t last_time = -1;
1297
    static int qp_histogram[52];
1298

    
1299
    if (!is_last_report) {
1300
        int64_t cur_time;
1301
        /* display the report every 0.5 seconds */
1302
        cur_time = av_gettime();
1303
        if (last_time == -1) {
1304
            last_time = cur_time;
1305
            return;
1306
        }
1307
        if ((cur_time - last_time) < 500000)
1308
            return;
1309
        last_time = cur_time;
1310
    }
1311

    
1312

    
1313
    oc = output_files[0];
1314

    
1315
    total_size = avio_size(oc->pb);
1316
    if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1317
        total_size= avio_tell(oc->pb);
1318

    
1319
    buf[0] = '\0';
1320
    ti1 = 1e10;
1321
    vid = 0;
1322
    for(i=0;i<nb_ostreams;i++) {
1323
        ost = ost_table[i];
1324
        enc = ost->st->codec;
1325
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1326
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1327
                     !ost->st->stream_copy ?
1328
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1329
        }
1330
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1331
            float t = (av_gettime()-timer_start) / 1000000.0;
1332

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

    
1379
    if (verbose || is_last_report) {
1380
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1381

    
1382
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1383
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1384
            (double)total_size / 1024, ti1, bitrate);
1385

    
1386
        if (nb_frames_dup || nb_frames_drop)
1387
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1388
                  nb_frames_dup, nb_frames_drop);
1389

    
1390
        if (verbose >= 0)
1391
            fprintf(stderr, "%s    \r", buf);
1392

    
1393
        fflush(stderr);
1394
    }
1395

    
1396
    if (is_last_report && verbose >= 0){
1397
        int64_t raw= audio_size + video_size + extra_size;
1398
        fprintf(stderr, "\n");
1399
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1400
                video_size/1024.0,
1401
                audio_size/1024.0,
1402
                extra_size/1024.0,
1403
                100.0*(total_size - raw)/raw
1404
        );
1405
    }
1406
}
1407

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

    
1426
    AVPacket avpkt;
1427
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1428

    
1429
    if(ist->next_pts == AV_NOPTS_VALUE)
1430
        ist->next_pts= ist->pts;
1431

    
1432
    if (pkt == NULL) {
1433
        /* EOF handling */
1434
        av_init_packet(&avpkt);
1435
        avpkt.data = NULL;
1436
        avpkt.size = 0;
1437
        goto handle_eof;
1438
    } else {
1439
        avpkt = *pkt;
1440
    }
1441

    
1442
    if(pkt->dts != AV_NOPTS_VALUE)
1443
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1444
    if(pkt->pts != AV_NOPTS_VALUE)
1445
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1446

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

    
1454
        if(avpkt.size && avpkt.size != pkt->size &&
1455
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1456
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1457
            ist->showed_multi_packet_warning=1;
1458
        }
1459

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

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

    
1553
        buffer_to_free = NULL;
1554
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1555
            pre_process_video_frame(ist, (AVPicture *)&picture,
1556
                                    &buffer_to_free);
1557
        }
1558

    
1559
#if CONFIG_AVFILTER
1560
        if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
1561
            for(i=0;i<nb_ostreams;i++) {
1562
                ost = ost_table[i];
1563
                if (ost->input_video_filter && ost->source_index == ist_index) {
1564
                    AVRational sar;
1565
                    if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1566
                    else                                  sar = ist->st->codec->sample_aspect_ratio;
1567
                    // add it to be filtered
1568
                    av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1569
                                             ist->pts,
1570
                                             sar);
1571
                }
1572
            }
1573
        }
1574
#endif
1575

    
1576
        // preprocess audio (volume)
1577
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1578
            if (audio_volume != 256) {
1579
                short *volp;
1580
                volp = samples;
1581
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1582
                    int v = ((*volp) * audio_volume + 128) >> 8;
1583
                    if (v < -32768) v = -32768;
1584
                    if (v >  32767) v = 32767;
1585
                    *volp++ = v;
1586
                }
1587
            }
1588
        }
1589

    
1590
        /* frame rate emulation */
1591
        if (rate_emu) {
1592
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1593
            int64_t now = av_gettime() - ist->start;
1594
            if (pts > now)
1595
                usleep(pts - now);
1596
        }
1597
        /* if output time reached then transcode raw format,
1598
           encode packets and output them */
1599
        if (start_time == 0 || ist->pts >= start_time)
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
#if CONFIG_AVFILTER
1606
                frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1607
                    !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1608
                while (frame_available) {
1609
                    AVRational ist_pts_tb;
1610
                    if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1611
                        get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1612
                    if (ost->picref)
1613
                        ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1614
#endif
1615
                    os = output_files[ost->file_index];
1616

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

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

    
1647
                        av_init_packet(&opkt);
1648

    
1649
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1650
#if !CONFIG_AVFILTER
1651
                            continue;
1652
#else
1653
                            goto cont;
1654
#endif
1655

    
1656
                        /* no reencoding needed : output the packet directly */
1657
                        /* force the input stream PTS */
1658

    
1659
                        avcodec_get_frame_defaults(&avframe);
1660
                        ost->st->codec->coded_frame= &avframe;
1661
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1662

    
1663
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1664
                            audio_size += data_size;
1665
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1666
                            video_size += data_size;
1667
                            ost->sync_opts++;
1668
                        }
1669

    
1670
                        opkt.stream_index= ost->index;
1671
                        if(pkt->pts != AV_NOPTS_VALUE)
1672
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1673
                        else
1674
                            opkt.pts= AV_NOPTS_VALUE;
1675

    
1676
                        if (pkt->dts == AV_NOPTS_VALUE)
1677
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1678
                        else
1679
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1680
                        opkt.dts -= ost_tb_start_time;
1681

    
1682
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1683
                        opkt.flags= pkt->flags;
1684

    
1685
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1686
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1687
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1688
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1689
                           ) {
1690
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1691
                                opkt.destruct= av_destruct_packet;
1692
                        } else {
1693
                            opkt.data = data_buf;
1694
                            opkt.size = data_size;
1695
                        }
1696

    
1697
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1698
                        ost->st->codec->frame_number++;
1699
                        ost->frame_number++;
1700
                        av_free_packet(&opkt);
1701
                    }
1702
#if CONFIG_AVFILTER
1703
                    cont:
1704
                    frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1705
                                       ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1706
                    if(ost->picref)
1707
                        avfilter_unref_buffer(ost->picref);
1708
                }
1709
#endif
1710
                }
1711
            }
1712

    
1713
        av_free(buffer_to_free);
1714
        /* XXX: allocate the subtitles in the codec ? */
1715
        if (subtitle_to_free) {
1716
            avsubtitle_free(subtitle_to_free);
1717
            subtitle_to_free = NULL;
1718
        }
1719
    }
1720
 discard_packet:
1721
    if (pkt == NULL) {
1722
        /* EOF handling */
1723

    
1724
        for(i=0;i<nb_ostreams;i++) {
1725
            ost = ost_table[i];
1726
            if (ost->source_index == ist_index) {
1727
                AVCodecContext *enc= ost->st->codec;
1728
                os = output_files[ost->file_index];
1729

    
1730
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1731
                    continue;
1732
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1733
                    continue;
1734

    
1735
                if (ost->encoding_needed) {
1736
                    for(;;) {
1737
                        AVPacket pkt;
1738
                        int fifo_bytes;
1739
                        av_init_packet(&pkt);
1740
                        pkt.stream_index= ost->index;
1741

    
1742
                        switch(ost->st->codec->codec_type) {
1743
                        case AVMEDIA_TYPE_AUDIO:
1744
                            fifo_bytes = av_fifo_size(ost->fifo);
1745
                            ret = 0;
1746
                            /* encode any samples remaining in fifo */
1747
                            if (fifo_bytes > 0) {
1748
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1749
                                int fs_tmp = enc->frame_size;
1750

    
1751
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1752
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1753
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1754
                                } else { /* pad */
1755
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1756
                                    if (allocated_audio_buf_size < frame_bytes)
1757
                                        ffmpeg_exit(1);
1758
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1759
                                }
1760

    
1761
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1762
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1763
                                                          ost->st->time_base.num, enc->sample_rate);
1764
                                enc->frame_size = fs_tmp;
1765
                            }
1766
                            if(ret <= 0) {
1767
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1768
                            }
1769
                            if (ret < 0) {
1770
                                fprintf(stderr, "Audio encoding failed\n");
1771
                                ffmpeg_exit(1);
1772
                            }
1773
                            audio_size += ret;
1774
                            pkt.flags |= AV_PKT_FLAG_KEY;
1775
                            break;
1776
                        case AVMEDIA_TYPE_VIDEO:
1777
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1778
                            if (ret < 0) {
1779
                                fprintf(stderr, "Video encoding failed\n");
1780
                                ffmpeg_exit(1);
1781
                            }
1782
                            video_size += ret;
1783
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1784
                                pkt.flags |= AV_PKT_FLAG_KEY;
1785
                            if (ost->logfile && enc->stats_out) {
1786
                                fprintf(ost->logfile, "%s", enc->stats_out);
1787
                            }
1788
                            break;
1789
                        default:
1790
                            ret=-1;
1791
                        }
1792

    
1793
                        if(ret<=0)
1794
                            break;
1795
                        pkt.data= bit_buffer;
1796
                        pkt.size= ret;
1797
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1798
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1799
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1800
                    }
1801
                }
1802
            }
1803
        }
1804
    }
1805

    
1806
    return 0;
1807
 fail_decode:
1808
    return -1;
1809
}
1810

    
1811
static void print_sdp(AVFormatContext **avc, int n)
1812
{
1813
    char sdp[2048];
1814

    
1815
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1816
    printf("SDP:\n%s\n", sdp);
1817
    fflush(stdout);
1818
}
1819

    
1820
static int copy_chapters(int infile, int outfile)
1821
{
1822
    AVFormatContext *is = input_files[infile];
1823
    AVFormatContext *os = output_files[outfile];
1824
    int i;
1825

    
1826
    for (i = 0; i < is->nb_chapters; i++) {
1827
        AVChapter *in_ch = is->chapters[i], *out_ch;
1828
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1829
                                      AV_TIME_BASE_Q, in_ch->time_base);
1830
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1831
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1832

    
1833

    
1834
        if (in_ch->end < ts_off)
1835
            continue;
1836
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1837
            break;
1838

    
1839
        out_ch = av_mallocz(sizeof(AVChapter));
1840
        if (!out_ch)
1841
            return AVERROR(ENOMEM);
1842

    
1843
        out_ch->id        = in_ch->id;
1844
        out_ch->time_base = in_ch->time_base;
1845
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1846
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1847

    
1848
        if (metadata_chapters_autocopy)
1849
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1850

    
1851
        os->nb_chapters++;
1852
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1853
        if (!os->chapters)
1854
            return AVERROR(ENOMEM);
1855
        os->chapters[os->nb_chapters - 1] = out_ch;
1856
    }
1857
    return 0;
1858
}
1859

    
1860
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1861
                                    AVCodecContext *avctx)
1862
{
1863
    char *p;
1864
    int n = 1, i;
1865
    int64_t t;
1866

    
1867
    for (p = kf; *p; p++)
1868
        if (*p == ',')
1869
            n++;
1870
    ost->forced_kf_count = n;
1871
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1872
    if (!ost->forced_kf_pts) {
1873
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1874
        ffmpeg_exit(1);
1875
    }
1876
    for (i = 0; i < n; i++) {
1877
        p = i ? strchr(p, ',') + 1 : kf;
1878
        t = parse_time_or_die("force_key_frames", p, 1);
1879
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1880
    }
1881
}
1882

    
1883
/*
1884
 * The following code is the main loop of the file converter
1885
 */
1886
static int transcode(AVFormatContext **output_files,
1887
                     int nb_output_files,
1888
                     AVFormatContext **input_files,
1889
                     int nb_input_files,
1890
                     AVStreamMap *stream_maps, int nb_stream_maps)
1891
{
1892
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1893
    AVFormatContext *is, *os;
1894
    AVCodecContext *codec, *icodec;
1895
    AVOutputStream *ost, **ost_table = NULL;
1896
    AVInputStream *ist, **ist_table = NULL;
1897
    AVInputFile *file_table;
1898
    char error[1024];
1899
    int key;
1900
    int want_sdp = 1;
1901
    uint8_t no_packet[MAX_FILES]={0};
1902
    int no_packet_count=0;
1903

    
1904
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1905
    if (!file_table)
1906
        goto fail;
1907

    
1908
    /* input stream init */
1909
    j = 0;
1910
    for(i=0;i<nb_input_files;i++) {
1911
        is = input_files[i];
1912
        file_table[i].ist_index = j;
1913
        file_table[i].nb_streams = is->nb_streams;
1914
        j += is->nb_streams;
1915
    }
1916
    nb_istreams = j;
1917

    
1918
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1919
    if (!ist_table)
1920
        goto fail;
1921

    
1922
    for(i=0;i<nb_istreams;i++) {
1923
        ist = av_mallocz(sizeof(AVInputStream));
1924
        if (!ist)
1925
            goto fail;
1926
        ist_table[i] = ist;
1927
    }
1928
    j = 0;
1929
    for(i=0;i<nb_input_files;i++) {
1930
        is = input_files[i];
1931
        for(k=0;k<is->nb_streams;k++) {
1932
            ist = ist_table[j++];
1933
            ist->st = is->streams[k];
1934
            ist->file_index = i;
1935
            ist->index = k;
1936
            ist->discard = 1; /* the stream is discarded by default
1937
                                 (changed later) */
1938

    
1939
            if (rate_emu) {
1940
                ist->start = av_gettime();
1941
            }
1942
        }
1943
    }
1944

    
1945
    /* output stream init */
1946
    nb_ostreams = 0;
1947
    for(i=0;i<nb_output_files;i++) {
1948
        os = output_files[i];
1949
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1950
            av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1951
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1952
            ret = AVERROR(EINVAL);
1953
            goto fail;
1954
        }
1955
        nb_ostreams += os->nb_streams;
1956
    }
1957
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1958
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1959
        ret = AVERROR(EINVAL);
1960
        goto fail;
1961
    }
1962

    
1963
    /* Sanity check the mapping args -- do the input files & streams exist? */
1964
    for(i=0;i<nb_stream_maps;i++) {
1965
        int fi = stream_maps[i].file_index;
1966
        int si = stream_maps[i].stream_index;
1967

    
1968
        if (fi < 0 || fi > nb_input_files - 1 ||
1969
            si < 0 || si > file_table[fi].nb_streams - 1) {
1970
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1971
            ret = AVERROR(EINVAL);
1972
            goto fail;
1973
        }
1974
        fi = stream_maps[i].sync_file_index;
1975
        si = stream_maps[i].sync_stream_index;
1976
        if (fi < 0 || fi > nb_input_files - 1 ||
1977
            si < 0 || si > file_table[fi].nb_streams - 1) {
1978
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1979
            ret = AVERROR(EINVAL);
1980
            goto fail;
1981
        }
1982
    }
1983

    
1984
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1985
    if (!ost_table)
1986
        goto fail;
1987
    n = 0;
1988
    for(k=0;k<nb_output_files;k++) {
1989
        os = output_files[k];
1990
        for(i=0;i<os->nb_streams;i++,n++) {
1991
            int found;
1992
            ost = ost_table[n] = output_streams_for_file[k][i];
1993
            ost->st = os->streams[i];
1994
            if (nb_stream_maps > 0) {
1995
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1996
                    stream_maps[n].stream_index;
1997

    
1998
                /* Sanity check that the stream types match */
1999
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2000
                    int i= ost->file_index;
2001
                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2002
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2003
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2004
                        ost->file_index, ost->index);
2005
                    ffmpeg_exit(1);
2006
                }
2007

    
2008
            } else {
2009
                int best_nb_frames=-1;
2010
                /* get corresponding input stream index : we select the first one with the right type */
2011
                found = 0;
2012
                for(j=0;j<nb_istreams;j++) {
2013
                    int skip=0;
2014
                    ist = ist_table[j];
2015
                    if(opt_programid){
2016
                        int pi,si;
2017
                        AVFormatContext *f= input_files[ ist->file_index ];
2018
                        skip=1;
2019
                        for(pi=0; pi<f->nb_programs; pi++){
2020
                            AVProgram *p= f->programs[pi];
2021
                            if(p->id == opt_programid)
2022
                                for(si=0; si<p->nb_stream_indexes; si++){
2023
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2024
                                        skip=0;
2025
                                }
2026
                        }
2027
                    }
2028
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2029
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2030
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2031
                            best_nb_frames= ist->st->codec_info_nb_frames;
2032
                            ost->source_index = j;
2033
                            found = 1;
2034
                        }
2035
                    }
2036
                }
2037

    
2038
                if (!found) {
2039
                    if(! opt_programid) {
2040
                        /* try again and reuse existing stream */
2041
                        for(j=0;j<nb_istreams;j++) {
2042
                            ist = ist_table[j];
2043
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2044
                                && ist->st->discard != AVDISCARD_ALL) {
2045
                                ost->source_index = j;
2046
                                found = 1;
2047
                            }
2048
                        }
2049
                    }
2050
                    if (!found) {
2051
                        int i= ost->file_index;
2052
                        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2053
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2054
                                ost->file_index, ost->index);
2055
                        ffmpeg_exit(1);
2056
                    }
2057
                }
2058
            }
2059
            ist = ist_table[ost->source_index];
2060
            ist->discard = 0;
2061
            ost->sync_ist = (nb_stream_maps > 0) ?
2062
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2063
                         stream_maps[n].sync_stream_index] : ist;
2064
        }
2065
    }
2066

    
2067
    /* for each output stream, we compute the right encoding parameters */
2068
    for(i=0;i<nb_ostreams;i++) {
2069
        ost = ost_table[i];
2070
        os = output_files[ost->file_index];
2071
        ist = ist_table[ost->source_index];
2072

    
2073
        codec = ost->st->codec;
2074
        icodec = ist->st->codec;
2075

    
2076
        if (metadata_streams_autocopy)
2077
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2078
                             AV_METADATA_DONT_OVERWRITE);
2079

    
2080
        ost->st->disposition = ist->st->disposition;
2081
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2082
        codec->chroma_sample_location = icodec->chroma_sample_location;
2083

    
2084
        if (ost->st->stream_copy) {
2085
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2086

    
2087
            if (extra_size > INT_MAX)
2088
                goto fail;
2089

    
2090
            /* if stream_copy is selected, no need to decode or encode */
2091
            codec->codec_id = icodec->codec_id;
2092
            codec->codec_type = icodec->codec_type;
2093

    
2094
            if(!codec->codec_tag){
2095
                if(   !os->oformat->codec_tag
2096
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2097
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2098
                    codec->codec_tag = icodec->codec_tag;
2099
            }
2100

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

    
2190
                    ost->original_height = icodec->height;
2191
                    ost->original_width  = icodec->width;
2192
#endif
2193
                    codec->bits_per_raw_sample= 0;
2194
                }
2195
                ost->resample_height = icodec->height;
2196
                ost->resample_width  = icodec->width;
2197
                ost->resample_pix_fmt= icodec->pix_fmt;
2198
                ost->encoding_needed = 1;
2199
                ist->decoding_needed = 1;
2200

    
2201
#if CONFIG_AVFILTER
2202
                if (configure_filters(ist, ost)) {
2203
                    fprintf(stderr, "Error opening filters!\n");
2204
                    exit(1);
2205
                }
2206
#endif
2207
                break;
2208
            case AVMEDIA_TYPE_SUBTITLE:
2209
                ost->encoding_needed = 1;
2210
                ist->decoding_needed = 1;
2211
                break;
2212
            default:
2213
                abort();
2214
                break;
2215
            }
2216
            /* two pass mode */
2217
            if (ost->encoding_needed &&
2218
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2219
                char logfilename[1024];
2220
                FILE *f;
2221

    
2222
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2223
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2224
                         i);
2225
                if (codec->flags & CODEC_FLAG_PASS1) {
2226
                    f = fopen(logfilename, "wb");
2227
                    if (!f) {
2228
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2229
                        ffmpeg_exit(1);
2230
                    }
2231
                    ost->logfile = f;
2232
                } else {
2233
                    char  *logbuffer;
2234
                    size_t logbuffer_size;
2235
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2236
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2237
                        ffmpeg_exit(1);
2238
                    }
2239
                    codec->stats_in = logbuffer;
2240
                }
2241
            }
2242
        }
2243
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2244
            int size= codec->width * codec->height;
2245
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2246
        }
2247
    }
2248

    
2249
    if (!bit_buffer)
2250
        bit_buffer = av_malloc(bit_buffer_size);
2251
    if (!bit_buffer) {
2252
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2253
                bit_buffer_size);
2254
        ret = AVERROR(ENOMEM);
2255
        goto fail;
2256
    }
2257

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

    
2291
    /* open each decoder */
2292
    for(i=0;i<nb_istreams;i++) {
2293
        ist = ist_table[i];
2294
        if (ist->decoding_needed) {
2295
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2296
            if (!codec)
2297
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2298
            if (!codec) {
2299
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2300
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2301
                ret = AVERROR(EINVAL);
2302
                goto dump_format;
2303
            }
2304
            if (avcodec_open(ist->st->codec, codec) < 0) {
2305
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2306
                        ist->file_index, ist->index);
2307
                ret = AVERROR(EINVAL);
2308
                goto dump_format;
2309
            }
2310
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2311
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2312
        }
2313
    }
2314

    
2315
    /* init pts */
2316
    for(i=0;i<nb_istreams;i++) {
2317
        AVStream *st;
2318
        ist = ist_table[i];
2319
        st= ist->st;
2320
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2321
        ist->next_pts = AV_NOPTS_VALUE;
2322
        ist->is_start = 1;
2323
    }
2324

    
2325
    /* set meta data information from input file if required */
2326
    for (i=0;i<nb_meta_data_maps;i++) {
2327
        AVFormatContext *files[2];
2328
        AVMetadata      **meta[2];
2329
        int j;
2330

    
2331
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2332
        if ((index) < 0 || (index) >= (nb_elems)) {\
2333
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2334
                     (desc), (index));\
2335
            ret = AVERROR(EINVAL);\
2336
            goto dump_format;\
2337
        }
2338

    
2339
        int out_file_index = meta_data_maps[i][0].file;
2340
        int in_file_index = meta_data_maps[i][1].file;
2341
        if (in_file_index < 0 || out_file_index < 0)
2342
            continue;
2343
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2344
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2345

    
2346
        files[0] = output_files[out_file_index];
2347
        files[1] = input_files[in_file_index];
2348

    
2349
        for (j = 0; j < 2; j++) {
2350
            AVMetaDataMap *map = &meta_data_maps[i][j];
2351

    
2352
            switch (map->type) {
2353
            case 'g':
2354
                meta[j] = &files[j]->metadata;
2355
                break;
2356
            case 's':
2357
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2358
                meta[j] = &files[j]->streams[map->index]->metadata;
2359
                break;
2360
            case 'c':
2361
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2362
                meta[j] = &files[j]->chapters[map->index]->metadata;
2363
                break;
2364
            case 'p':
2365
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2366
                meta[j] = &files[j]->programs[map->index]->metadata;
2367
                break;
2368
            }
2369
        }
2370

    
2371
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2372
    }
2373

    
2374
    /* copy global metadata by default */
2375
    if (metadata_global_autocopy) {
2376

    
2377
        for (i = 0; i < nb_output_files; i++)
2378
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2379
                             AV_METADATA_DONT_OVERWRITE);
2380
    }
2381

    
2382
    /* copy chapters according to chapter maps */
2383
    for (i = 0; i < nb_chapter_maps; i++) {
2384
        int infile  = chapter_maps[i].in_file;
2385
        int outfile = chapter_maps[i].out_file;
2386

    
2387
        if (infile < 0 || outfile < 0)
2388
            continue;
2389
        if (infile >= nb_input_files) {
2390
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2391
            ret = AVERROR(EINVAL);
2392
            goto dump_format;
2393
        }
2394
        if (outfile >= nb_output_files) {
2395
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2396
            ret = AVERROR(EINVAL);
2397
            goto dump_format;
2398
        }
2399
        copy_chapters(infile, outfile);
2400
    }
2401

    
2402
    /* copy chapters from the first input file that has them*/
2403
    if (!nb_chapter_maps)
2404
        for (i = 0; i < nb_input_files; i++) {
2405
            if (!input_files[i]->nb_chapters)
2406
                continue;
2407

    
2408
            for (j = 0; j < nb_output_files; j++)
2409
                if ((ret = copy_chapters(i, j)) < 0)
2410
                    goto dump_format;
2411
            break;
2412
        }
2413

    
2414
    /* open files and write file headers */
2415
    for(i=0;i<nb_output_files;i++) {
2416
        os = output_files[i];
2417
        if (av_write_header(os) < 0) {
2418
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2419
            ret = AVERROR(EINVAL);
2420
            goto dump_format;
2421
        }
2422
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2423
            want_sdp = 0;
2424
        }
2425
    }
2426

    
2427
 dump_format:
2428
    /* dump the file output parameters - cannot be done before in case
2429
       of stream copy */
2430
    for(i=0;i<nb_output_files;i++) {
2431
        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2432
    }
2433

    
2434
    /* dump the stream mapping */
2435
    if (verbose >= 0) {
2436
        fprintf(stderr, "Stream mapping:\n");
2437
        for(i=0;i<nb_ostreams;i++) {
2438
            ost = ost_table[i];
2439
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2440
                    ist_table[ost->source_index]->file_index,
2441
                    ist_table[ost->source_index]->index,
2442
                    ost->file_index,
2443
                    ost->index);
2444
            if (ost->sync_ist != ist_table[ost->source_index])
2445
                fprintf(stderr, " [sync #%d.%d]",
2446
                        ost->sync_ist->file_index,
2447
                        ost->sync_ist->index);
2448
            fprintf(stderr, "\n");
2449
        }
2450
    }
2451

    
2452
    if (ret) {
2453
        fprintf(stderr, "%s\n", error);
2454
        goto fail;
2455
    }
2456

    
2457
    if (want_sdp) {
2458
        print_sdp(output_files, nb_output_files);
2459
    }
2460

    
2461
    if (!using_stdin) {
2462
        if(verbose >= 0)
2463
#if HAVE_KBHIT
2464
            fprintf(stderr, "Press [q] to stop encoding\n");
2465
#else
2466
            fprintf(stderr, "Press ctrl-c to stop encoding\n");
2467
#endif
2468
        url_set_interrupt_cb(decode_interrupt_cb);
2469
    }
2470
    term_init();
2471

    
2472
    timer_start = av_gettime();
2473

    
2474
    for(; received_sigterm == 0;) {
2475
        int file_index, ist_index;
2476
        AVPacket pkt;
2477
        double ipts_min;
2478
        double opts_min;
2479

    
2480
    redo:
2481
        ipts_min= 1e100;
2482
        opts_min= 1e100;
2483
        /* if 'q' pressed, exits */
2484
        if (!using_stdin) {
2485
            if (q_pressed)
2486
                break;
2487
            /* read_key() returns 0 on EOF */
2488
            key = read_key();
2489
            if (key == 'q')
2490
                break;
2491
        }
2492

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

    
2531
        /* finish if limit size exhausted */
2532
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2533
            break;
2534

    
2535
        /* read a frame from it and output it in the fifo */
2536
        is = input_files[file_index];
2537
        ret= av_read_frame(is, &pkt);
2538
        if(ret == AVERROR(EAGAIN)){
2539
            no_packet[file_index]=1;
2540
            no_packet_count++;
2541
            continue;
2542
        }
2543
        if (ret < 0) {
2544
            file_table[file_index].eof_reached = 1;
2545
            if (opt_shortest)
2546
                break;
2547
            else
2548
                continue;
2549
        }
2550

    
2551
        no_packet_count=0;
2552
        memset(no_packet, 0, sizeof(no_packet));
2553

    
2554
        if (do_pkt_dump) {
2555
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2556
                             is->streams[pkt.stream_index]);
2557
        }
2558
        /* the following test is needed in case new streams appear
2559
           dynamically in stream : we ignore them */
2560
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2561
            goto discard_packet;
2562
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2563
        ist = ist_table[ist_index];
2564
        if (ist->discard)
2565
            goto discard_packet;
2566

    
2567
        if (pkt.dts != AV_NOPTS_VALUE)
2568
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2569
        if (pkt.pts != AV_NOPTS_VALUE)
2570
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2571

    
2572
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2573
            && input_files_ts_scale[file_index][pkt.stream_index]){
2574
            if(pkt.pts != AV_NOPTS_VALUE)
2575
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2576
            if(pkt.dts != AV_NOPTS_VALUE)
2577
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2578
        }
2579

    
2580
//        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);
2581
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2582
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2583
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2584
            int64_t delta= pkt_dts - ist->next_pts;
2585
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2586
                input_files_ts_offset[ist->file_index]-= delta;
2587
                if (verbose > 2)
2588
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2589
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2590
                if(pkt.pts != AV_NOPTS_VALUE)
2591
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2592
            }
2593
        }
2594

    
2595
        /* finish if recording time exhausted */
2596
        if (recording_time != INT64_MAX &&
2597
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2598
            ist->is_past_recording_time = 1;
2599
            goto discard_packet;
2600
        }
2601

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

    
2605
            if (verbose >= 0)
2606
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2607
                        ist->file_index, ist->index);
2608
            if (exit_on_error)
2609
                ffmpeg_exit(1);
2610
            av_free_packet(&pkt);
2611
            goto redo;
2612
        }
2613

    
2614
    discard_packet:
2615
        av_free_packet(&pkt);
2616

    
2617
        /* dump report by using the output first video and audio streams */
2618
        print_report(output_files, ost_table, nb_ostreams, 0);
2619
    }
2620

    
2621
    /* at the end of stream, we must flush the decoder buffers */
2622
    for(i=0;i<nb_istreams;i++) {
2623
        ist = ist_table[i];
2624
        if (ist->decoding_needed) {
2625
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2626
        }
2627
    }
2628

    
2629
    term_exit();
2630

    
2631
    /* write the trailer if needed and close file */
2632
    for(i=0;i<nb_output_files;i++) {
2633
        os = output_files[i];
2634
        av_write_trailer(os);
2635
    }
2636

    
2637
    /* dump report by using the first video and audio streams */
2638
    print_report(output_files, ost_table, nb_ostreams, 1);
2639

    
2640
    /* close each encoder */
2641
    for(i=0;i<nb_ostreams;i++) {
2642
        ost = ost_table[i];
2643
        if (ost->encoding_needed) {
2644
            av_freep(&ost->st->codec->stats_in);
2645
            avcodec_close(ost->st->codec);
2646
        }
2647
#if CONFIG_AVFILTER
2648
        avfilter_graph_free(&ost->graph);
2649
#endif
2650
    }
2651

    
2652
    /* close each decoder */
2653
    for(i=0;i<nb_istreams;i++) {
2654
        ist = ist_table[i];
2655
        if (ist->decoding_needed) {
2656
            avcodec_close(ist->st->codec);
2657
        }
2658
    }
2659

    
2660
    /* finished ! */
2661
    ret = 0;
2662

    
2663
 fail:
2664
    av_freep(&bit_buffer);
2665
    av_free(file_table);
2666

    
2667
    if (ist_table) {
2668
        for(i=0;i<nb_istreams;i++) {
2669
            ist = ist_table[i];
2670
            av_free(ist);
2671
        }
2672
        av_free(ist_table);
2673
    }
2674
    if (ost_table) {
2675
        for(i=0;i<nb_ostreams;i++) {
2676
            ost = ost_table[i];
2677
            if (ost) {
2678
                if (ost->st->stream_copy)
2679
                    av_freep(&ost->st->codec->extradata);
2680
                if (ost->logfile) {
2681
                    fclose(ost->logfile);
2682
                    ost->logfile = NULL;
2683
                }
2684
                av_fifo_free(ost->fifo); /* works even if fifo is not
2685
                                             initialized but set to zero */
2686
                av_freep(&ost->st->codec->subtitle_header);
2687
                av_free(ost->pict_tmp.data[0]);
2688
                av_free(ost->forced_kf_pts);
2689
                if (ost->video_resample)
2690
                    sws_freeContext(ost->img_resample_ctx);
2691
                if (ost->resample)
2692
                    audio_resample_close(ost->resample);
2693
                if (ost->reformat_ctx)
2694
                    av_audio_convert_free(ost->reformat_ctx);
2695
                av_free(ost);
2696
            }
2697
        }
2698
        av_free(ost_table);
2699
    }
2700
    return ret;
2701
}
2702

    
2703
static void opt_format(const char *arg)
2704
{
2705
    last_asked_format = arg;
2706
}
2707

    
2708
static void opt_video_rc_override_string(const char *arg)
2709
{
2710
    video_rc_override_string = arg;
2711
}
2712

    
2713
static int opt_me_threshold(const char *opt, const char *arg)
2714
{
2715
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2716
    return 0;
2717
}
2718

    
2719
static int opt_verbose(const char *opt, const char *arg)
2720
{
2721
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2722
    return 0;
2723
}
2724

    
2725
static int opt_frame_rate(const char *opt, const char *arg)
2726
{
2727
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2728
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2729
        ffmpeg_exit(1);
2730
    }
2731
    return 0;
2732
}
2733

    
2734
static int opt_bitrate(const char *opt, const char *arg)
2735
{
2736
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2737

    
2738
    opt_default(opt, arg);
2739

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

    
2743
    return 0;
2744
}
2745

    
2746
static int opt_frame_crop(const char *opt, const char *arg)
2747
{
2748
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2749
    return AVERROR(EINVAL);
2750
}
2751

    
2752
static void opt_frame_size(const char *arg)
2753
{
2754
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2755
        fprintf(stderr, "Incorrect frame size\n");
2756
        ffmpeg_exit(1);
2757
    }
2758
}
2759

    
2760
static int opt_pad(const char *opt, const char *arg) {
2761
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2762
    return -1;
2763
}
2764

    
2765
static void opt_frame_pix_fmt(const char *arg)
2766
{
2767
    if (strcmp(arg, "list")) {
2768
        frame_pix_fmt = av_get_pix_fmt(arg);
2769
        if (frame_pix_fmt == PIX_FMT_NONE) {
2770
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2771
            ffmpeg_exit(1);
2772
        }
2773
    } else {
2774
        show_pix_fmts();
2775
        ffmpeg_exit(0);
2776
    }
2777
}
2778

    
2779
static void opt_frame_aspect_ratio(const char *arg)
2780
{
2781
    int x = 0, y = 0;
2782
    double ar = 0;
2783
    const char *p;
2784
    char *end;
2785

    
2786
    p = strchr(arg, ':');
2787
    if (p) {
2788
        x = strtol(arg, &end, 10);
2789
        if (end == p)
2790
            y = strtol(end+1, &end, 10);
2791
        if (x > 0 && y > 0)
2792
            ar = (double)x / (double)y;
2793
    } else
2794
        ar = strtod(arg, NULL);
2795

    
2796
    if (!ar) {
2797
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2798
        ffmpeg_exit(1);
2799
    }
2800
    frame_aspect_ratio = ar;
2801
}
2802

    
2803
static int opt_metadata(const char *opt, const char *arg)
2804
{
2805
    char *mid= strchr(arg, '=');
2806

    
2807
    if(!mid){
2808
        fprintf(stderr, "Missing =\n");
2809
        ffmpeg_exit(1);
2810
    }
2811
    *mid++= 0;
2812

    
2813
    av_metadata_set2(&metadata, arg, mid, 0);
2814

    
2815
    return 0;
2816
}
2817

    
2818
static void opt_qscale(const char *arg)
2819
{
2820
    video_qscale = atof(arg);
2821
    if (video_qscale <= 0 ||
2822
        video_qscale > 255) {
2823
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2824
        ffmpeg_exit(1);
2825
    }
2826
}
2827

    
2828
static void opt_top_field_first(const char *arg)
2829
{
2830
    top_field_first= atoi(arg);
2831
}
2832

    
2833
static int opt_thread_count(const char *opt, const char *arg)
2834
{
2835
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2836
#if !HAVE_THREADS
2837
    if (verbose >= 0)
2838
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2839
#endif
2840
    return 0;
2841
}
2842

    
2843
static void opt_audio_sample_fmt(const char *arg)
2844
{
2845
    if (strcmp(arg, "list")) {
2846
        audio_sample_fmt = av_get_sample_fmt(arg);
2847
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2848
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2849
            ffmpeg_exit(1);
2850
        }
2851
    } else {
2852
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2853
        ffmpeg_exit(0);
2854
    }
2855
}
2856

    
2857
static int opt_audio_rate(const char *opt, const char *arg)
2858
{
2859
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2860
    return 0;
2861
}
2862

    
2863
static int opt_audio_channels(const char *opt, const char *arg)
2864
{
2865
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2866
    return 0;
2867
}
2868

    
2869
static void opt_video_channel(const char *arg)
2870
{
2871
    video_channel = strtol(arg, NULL, 0);
2872
}
2873

    
2874
static void opt_video_standard(const char *arg)
2875
{
2876
    video_standard = av_strdup(arg);
2877
}
2878

    
2879
static void opt_codec(int *pstream_copy, char **pcodec_name,
2880
                      int codec_type, const char *arg)
2881
{
2882
    av_freep(pcodec_name);
2883
    if (!strcmp(arg, "copy")) {
2884
        *pstream_copy = 1;
2885
    } else {
2886
        *pcodec_name = av_strdup(arg);
2887
    }
2888
}
2889

    
2890
static void opt_audio_codec(const char *arg)
2891
{
2892
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2893
}
2894

    
2895
static void opt_video_codec(const char *arg)
2896
{
2897
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2898
}
2899

    
2900
static void opt_subtitle_codec(const char *arg)
2901
{
2902
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2903
}
2904

    
2905
static int opt_codec_tag(const char *opt, const char *arg)
2906
{
2907
    char *tail;
2908
    uint32_t *codec_tag;
2909

    
2910
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2911
                !strcmp(opt, "vtag") ? &video_codec_tag :
2912
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2913
    if (!codec_tag)
2914
        return -1;
2915

    
2916
    *codec_tag = strtol(arg, &tail, 0);
2917
    if (!tail || *tail)
2918
        *codec_tag = AV_RL32(arg);
2919

    
2920
    return 0;
2921
}
2922

    
2923
static void opt_map(const char *arg)
2924
{
2925
    AVStreamMap *m;
2926
    char *p;
2927

    
2928
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2929
    m = &stream_maps[nb_stream_maps-1];
2930

    
2931
    m->file_index = strtol(arg, &p, 0);
2932
    if (*p)
2933
        p++;
2934

    
2935
    m->stream_index = strtol(p, &p, 0);
2936
    if (*p) {
2937
        p++;
2938
        m->sync_file_index = strtol(p, &p, 0);
2939
        if (*p)
2940
            p++;
2941
        m->sync_stream_index = strtol(p, &p, 0);
2942
    } else {
2943
        m->sync_file_index = m->file_index;
2944
        m->sync_stream_index = m->stream_index;
2945
    }
2946
}
2947

    
2948
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2949
{
2950
    *endptr = arg;
2951
    if (*arg == ',') {
2952
        *type = *(++arg);
2953
        switch (*arg) {
2954
        case 'g':
2955
            break;
2956
        case 's':
2957
        case 'c':
2958
        case 'p':
2959
            *index = strtol(++arg, endptr, 0);
2960
            break;
2961
        default:
2962
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2963
            ffmpeg_exit(1);
2964
        }
2965
    } else
2966
        *type = 'g';
2967
}
2968

    
2969
static void opt_map_metadata(const char *arg)
2970
{
2971
    AVMetaDataMap *m, *m1;
2972
    char *p;
2973

    
2974
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2975
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2976

    
2977
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
2978
    m->file = strtol(arg, &p, 0);
2979
    parse_meta_type(p, &m->type, &m->index, &p);
2980
    if (*p)
2981
        p++;
2982

    
2983
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2984
    m1->file = strtol(p, &p, 0);
2985
    parse_meta_type(p, &m1->type, &m1->index, &p);
2986

    
2987
    if (m->type == 'g' || m1->type == 'g')
2988
        metadata_global_autocopy = 0;
2989
    if (m->type == 's' || m1->type == 's')
2990
        metadata_streams_autocopy = 0;
2991
    if (m->type == 'c' || m1->type == 'c')
2992
        metadata_chapters_autocopy = 0;
2993
}
2994

    
2995
static void opt_map_meta_data(const char *arg)
2996
{
2997
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2998
                    "Use -map_metadata instead.\n");
2999
    opt_map_metadata(arg);
3000
}
3001

    
3002
static void opt_map_chapters(const char *arg)
3003
{
3004
    AVChapterMap *c;
3005
    char *p;
3006

    
3007
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3008
                              nb_chapter_maps + 1);
3009
    c = &chapter_maps[nb_chapter_maps - 1];
3010
    c->out_file = strtol(arg, &p, 0);
3011
    if (*p)
3012
        p++;
3013

    
3014
    c->in_file = strtol(p, &p, 0);
3015
}
3016

    
3017
static void opt_input_ts_scale(const char *arg)
3018
{
3019
    unsigned int stream;
3020
    double scale;
3021
    char *p;
3022

    
3023
    stream = strtol(arg, &p, 0);
3024
    if (*p)
3025
        p++;
3026
    scale= strtod(p, &p);
3027

    
3028
    if(stream >= MAX_STREAMS)
3029
        ffmpeg_exit(1);
3030

    
3031
    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);
3032
    input_files_ts_scale[nb_input_files][stream]= scale;
3033
}
3034

    
3035
static int opt_recording_time(const char *opt, const char *arg)
3036
{
3037
    recording_time = parse_time_or_die(opt, arg, 1);
3038
    return 0;
3039
}
3040

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

    
3047
static int opt_recording_timestamp(const char *opt, const char *arg)
3048
{
3049
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3050
    return 0;
3051
}
3052

    
3053
static int opt_input_ts_offset(const char *opt, const char *arg)
3054
{
3055
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3056
    return 0;
3057
}
3058

    
3059
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3060
{
3061
    const char *codec_string = encoder ? "encoder" : "decoder";
3062
    AVCodec *codec;
3063

    
3064
    if(!name)
3065
        return CODEC_ID_NONE;
3066
    codec = encoder ?
3067
        avcodec_find_encoder_by_name(name) :
3068
        avcodec_find_decoder_by_name(name);
3069
    if(!codec) {
3070
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3071
        ffmpeg_exit(1);
3072
    }
3073
    if(codec->type != type) {
3074
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3075
        ffmpeg_exit(1);
3076
    }
3077
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3078
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3079
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3080
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3081
                codec_string, codec->name);
3082
        codec = encoder ?
3083
            avcodec_find_encoder(codec->id) :
3084
            avcodec_find_decoder(codec->id);
3085
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3086
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3087
                    codec_string, codec->name);
3088
        ffmpeg_exit(1);
3089
    }
3090
    return codec->id;
3091
}
3092

    
3093
static void opt_input_file(const char *filename)
3094
{
3095
    AVFormatContext *ic;
3096
    AVFormatParameters params, *ap = &params;
3097
    AVInputFormat *file_iformat = NULL;
3098
    int err, i, ret, rfps, rfps_base;
3099
    int64_t timestamp;
3100

    
3101
    if (last_asked_format) {
3102
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3103
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3104
            ffmpeg_exit(1);
3105
        }
3106
        last_asked_format = NULL;
3107
    }
3108

    
3109
    if (!strcmp(filename, "-"))
3110
        filename = "pipe:";
3111

    
3112
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3113
                    !strcmp(filename, "/dev/stdin");
3114

    
3115
    /* get default parameters from command line */
3116
    ic = avformat_alloc_context();
3117
    if (!ic) {
3118
        print_error(filename, AVERROR(ENOMEM));
3119
        ffmpeg_exit(1);
3120
    }
3121

    
3122
    memset(ap, 0, sizeof(*ap));
3123
    ap->prealloced_context = 1;
3124
    ap->sample_rate = audio_sample_rate;
3125
    ap->channels = audio_channels;
3126
    ap->time_base.den = frame_rate.num;
3127
    ap->time_base.num = frame_rate.den;
3128
    ap->width = frame_width;
3129
    ap->height = frame_height;
3130
    ap->pix_fmt = frame_pix_fmt;
3131
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3132
    ap->channel = video_channel;
3133
    ap->standard = video_standard;
3134

    
3135
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3136

    
3137
    ic->video_codec_id   =
3138
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3139
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3140
    ic->audio_codec_id   =
3141
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3142
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3143
    ic->subtitle_codec_id=
3144
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3145
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3146
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3147

    
3148
    /* open the input file with generic libav function */
3149
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3150
    if (err < 0) {
3151
        print_error(filename, err);
3152
        ffmpeg_exit(1);
3153
    }
3154
    if(opt_programid) {
3155
        int i, j;
3156
        int found=0;
3157
        for(i=0; i<ic->nb_streams; i++){
3158
            ic->streams[i]->discard= AVDISCARD_ALL;
3159
        }
3160
        for(i=0; i<ic->nb_programs; i++){
3161
            AVProgram *p= ic->programs[i];
3162
            if(p->id != opt_programid){
3163
                p->discard = AVDISCARD_ALL;
3164
            }else{
3165
                found=1;
3166
                for(j=0; j<p->nb_stream_indexes; j++){
3167
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3168
                }
3169
            }
3170
        }
3171
        if(!found){
3172
            fprintf(stderr, "Specified program id not found\n");
3173
            ffmpeg_exit(1);
3174
        }
3175
        opt_programid=0;
3176
    }
3177

    
3178
    ic->loop_input = loop_input;
3179

    
3180
    /* If not enough info to get the stream parameters, we decode the
3181
       first frames to get it. (used in mpeg case for example) */
3182
    ret = av_find_stream_info(ic);
3183
    if (ret < 0 && verbose >= 0) {
3184
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3185
        av_close_input_file(ic);
3186
        ffmpeg_exit(1);
3187
    }
3188

    
3189
    timestamp = start_time;
3190
    /* add the stream start time */
3191
    if (ic->start_time != AV_NOPTS_VALUE)
3192
        timestamp += ic->start_time;
3193

    
3194
    /* if seeking requested, we execute it */
3195
    if (start_time != 0) {
3196
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3197
        if (ret < 0) {
3198
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3199
                    filename, (double)timestamp / AV_TIME_BASE);
3200
        }
3201
        /* reset seek info */
3202
        start_time = 0;
3203
    }
3204

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

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

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

    
3257
                    (float)rfps / rfps_base, rfps, rfps_base);
3258
            }
3259
            /* update the current frame rate to match the stream frame rate */
3260
            frame_rate.num = rfps;
3261
            frame_rate.den = rfps_base;
3262

    
3263
            if(video_disable)
3264
                st->discard= AVDISCARD_ALL;
3265
            else if(video_discard)
3266
                st->discard= video_discard;
3267
            break;
3268
        case AVMEDIA_TYPE_DATA:
3269
            break;
3270
        case AVMEDIA_TYPE_SUBTITLE:
3271
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3272
            if(subtitle_disable)
3273
                st->discard = AVDISCARD_ALL;
3274
            break;
3275
        case AVMEDIA_TYPE_ATTACHMENT:
3276
        case AVMEDIA_TYPE_UNKNOWN:
3277
            break;
3278
        default:
3279
            abort();
3280
        }
3281
    }
3282

    
3283
    input_files[nb_input_files] = ic;
3284
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3285
    /* dump the file content */
3286
    if (verbose >= 0)
3287
        av_dump_format(ic, nb_input_files, filename, 0);
3288

    
3289
    nb_input_files++;
3290

    
3291
    video_channel = 0;
3292

    
3293
    av_freep(&video_codec_name);
3294
    av_freep(&audio_codec_name);
3295
    av_freep(&subtitle_codec_name);
3296
}
3297

    
3298
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3299
                                         int *has_subtitle_ptr)
3300
{
3301
    int has_video, has_audio, has_subtitle, i, j;
3302
    AVFormatContext *ic;
3303

    
3304
    has_video = 0;
3305
    has_audio = 0;
3306
    has_subtitle = 0;
3307
    for(j=0;j<nb_input_files;j++) {
3308
        ic = input_files[j];
3309
        for(i=0;i<ic->nb_streams;i++) {
3310
            AVCodecContext *enc = ic->streams[i]->codec;
3311
            switch(enc->codec_type) {
3312
            case AVMEDIA_TYPE_AUDIO:
3313
                has_audio = 1;
3314
                break;
3315
            case AVMEDIA_TYPE_VIDEO:
3316
                has_video = 1;
3317
                break;
3318
            case AVMEDIA_TYPE_SUBTITLE:
3319
                has_subtitle = 1;
3320
                break;
3321
            case AVMEDIA_TYPE_DATA:
3322
            case AVMEDIA_TYPE_ATTACHMENT:
3323
            case AVMEDIA_TYPE_UNKNOWN:
3324
                break;
3325
            default:
3326
                abort();
3327
            }
3328
        }
3329
    }
3330
    *has_video_ptr = has_video;
3331
    *has_audio_ptr = has_audio;
3332
    *has_subtitle_ptr = has_subtitle;
3333
}
3334

    
3335
static void new_video_stream(AVFormatContext *oc, int file_idx)
3336
{
3337
    AVStream *st;
3338
    AVOutputStream *ost;
3339
    AVCodecContext *video_enc;
3340
    enum CodecID codec_id = CODEC_ID_NONE;
3341
    AVCodec *codec= NULL;
3342
    int i;
3343

    
3344
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3345
    if (!st) {
3346
        fprintf(stderr, "Could not alloc stream\n");
3347
        ffmpeg_exit(1);
3348
    }
3349
    ost = new_output_stream(oc, file_idx);
3350

    
3351
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3352
    if(!video_stream_copy){
3353
        if (video_codec_name) {
3354
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3355
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3356
            codec = avcodec_find_encoder_by_name(video_codec_name);
3357
            output_codecs[nb_output_codecs-1] = codec;
3358
        } else {
3359
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3360
            codec = avcodec_find_encoder(codec_id);
3361
        }
3362
#if CONFIG_AVFILTER
3363
        if(frame_aspect_ratio > 0){
3364
            i = vfilters ? strlen(vfilters) : 0;
3365
            vfilters = av_realloc(vfilters, i+100);
3366
            snprintf(vfilters+i, i+100, "%csetdar=%f\n", i?',':' ', frame_aspect_ratio);
3367
            frame_aspect_ratio=0;
3368
        }
3369

    
3370
        ost->avfilter= vfilters;
3371
        vfilters= NULL;
3372
#endif
3373
    }
3374

    
3375
    avcodec_get_context_defaults3(st->codec, codec);
3376
    ost->bitstream_filters = video_bitstream_filters;
3377
    video_bitstream_filters= NULL;
3378

    
3379
    st->codec->thread_count= thread_count;
3380

    
3381
    video_enc = st->codec;
3382

    
3383
    if(video_codec_tag)
3384
        video_enc->codec_tag= video_codec_tag;
3385

    
3386
    if(   (video_global_header&1)
3387
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3388
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3389
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3390
    }
3391
    if(video_global_header&2){
3392
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3393
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3394
    }
3395

    
3396
    if (video_stream_copy) {
3397
        st->stream_copy = 1;
3398
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3399
        video_enc->sample_aspect_ratio =
3400
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3401
    } else {
3402
        const char *p;
3403
        int i;
3404
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3405

    
3406
        video_enc->codec_id = codec_id;
3407
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3408

    
3409
        if (codec && codec->supported_framerates && !force_fps)
3410
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3411
        video_enc->time_base.den = fps.num;
3412
        video_enc->time_base.num = fps.den;
3413

    
3414
        video_enc->width = frame_width;
3415
        video_enc->height = frame_height;
3416
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3417
        video_enc->pix_fmt = frame_pix_fmt;
3418
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3419

    
3420
        choose_pixel_fmt(st, codec);
3421

    
3422
        if (intra_only)
3423
            video_enc->gop_size = 0;
3424
        if (video_qscale || same_quality) {
3425
            video_enc->flags |= CODEC_FLAG_QSCALE;
3426
            video_enc->global_quality=
3427
                st->quality = FF_QP2LAMBDA * video_qscale;
3428
        }
3429

    
3430
        if(intra_matrix)
3431
            video_enc->intra_matrix = intra_matrix;
3432
        if(inter_matrix)
3433
            video_enc->inter_matrix = inter_matrix;
3434

    
3435
        p= video_rc_override_string;
3436
        for(i=0; p; i++){
3437
            int start, end, q;
3438
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3439
            if(e!=3){
3440
                fprintf(stderr, "error parsing rc_override\n");
3441
                ffmpeg_exit(1);
3442
            }
3443
            video_enc->rc_override=
3444
                av_realloc(video_enc->rc_override,
3445
                           sizeof(RcOverride)*(i+1));
3446
            video_enc->rc_override[i].start_frame= start;
3447
            video_enc->rc_override[i].end_frame  = end;
3448
            if(q>0){
3449
                video_enc->rc_override[i].qscale= q;
3450
                video_enc->rc_override[i].quality_factor= 1.0;
3451
            }
3452
            else{
3453
                video_enc->rc_override[i].qscale= 0;
3454
                video_enc->rc_override[i].quality_factor= -q/100.0;
3455
            }
3456
            p= strchr(p, '/');
3457
            if(p) p++;
3458
        }
3459
        video_enc->rc_override_count=i;
3460
        if (!video_enc->rc_initial_buffer_occupancy)
3461
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3462
        video_enc->me_threshold= me_threshold;
3463
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3464

    
3465
        if (do_psnr)
3466
            video_enc->flags|= CODEC_FLAG_PSNR;
3467

    
3468
        /* two pass mode */
3469
        if (do_pass) {
3470
            if (do_pass == 1) {
3471
                video_enc->flags |= CODEC_FLAG_PASS1;
3472
            } else {
3473
                video_enc->flags |= CODEC_FLAG_PASS2;
3474
            }
3475
        }
3476

    
3477
        if (forced_key_frames)
3478
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3479
    }
3480
    if (video_language) {
3481
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3482
        av_freep(&video_language);
3483
    }
3484

    
3485
    /* reset some key parameters */
3486
    video_disable = 0;
3487
    av_freep(&video_codec_name);
3488
    av_freep(&forced_key_frames);
3489
    video_stream_copy = 0;
3490
    frame_pix_fmt = PIX_FMT_NONE;
3491
}
3492

    
3493
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3494
{
3495
    AVStream *st;
3496
    AVOutputStream *ost;
3497
    AVCodec *codec= NULL;
3498
    AVCodecContext *audio_enc;
3499
    enum CodecID codec_id = CODEC_ID_NONE;
3500

    
3501
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3502
    if (!st) {
3503
        fprintf(stderr, "Could not alloc stream\n");
3504
        ffmpeg_exit(1);
3505
    }
3506
    ost = new_output_stream(oc, file_idx);
3507

    
3508
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3509
    if(!audio_stream_copy){
3510
        if (audio_codec_name) {
3511
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3512
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3513
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3514
            output_codecs[nb_output_codecs-1] = codec;
3515
        } else {
3516
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3517
            codec = avcodec_find_encoder(codec_id);
3518
        }
3519
    }
3520

    
3521
    avcodec_get_context_defaults3(st->codec, codec);
3522

    
3523
    ost->bitstream_filters = audio_bitstream_filters;
3524
    audio_bitstream_filters= NULL;
3525

    
3526
    st->codec->thread_count= thread_count;
3527

    
3528
    audio_enc = st->codec;
3529
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3530

    
3531
    if(audio_codec_tag)
3532
        audio_enc->codec_tag= audio_codec_tag;
3533

    
3534
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3535
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3536
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3537
    }
3538
    if (audio_stream_copy) {
3539
        st->stream_copy = 1;
3540
        audio_enc->channels = audio_channels;
3541
        audio_enc->sample_rate = audio_sample_rate;
3542
    } else {
3543
        audio_enc->codec_id = codec_id;
3544
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3545

    
3546
        if (audio_qscale > QSCALE_NONE) {
3547
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3548
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3549
        }
3550
        audio_enc->channels = audio_channels;
3551
        audio_enc->sample_fmt = audio_sample_fmt;
3552
        audio_enc->sample_rate = audio_sample_rate;
3553
        audio_enc->channel_layout = channel_layout;
3554
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3555
            audio_enc->channel_layout = 0;
3556
        choose_sample_fmt(st, codec);
3557
        choose_sample_rate(st, codec);
3558
    }
3559
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3560
    if (audio_language) {
3561
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3562
        av_freep(&audio_language);
3563
    }
3564

    
3565
    /* reset some key parameters */
3566
    audio_disable = 0;
3567
    av_freep(&audio_codec_name);
3568
    audio_stream_copy = 0;
3569
}
3570

    
3571
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3572
{
3573
    AVStream *st;
3574
    AVOutputStream *ost;
3575
    AVCodec *codec=NULL;
3576
    AVCodecContext *subtitle_enc;
3577
    enum CodecID codec_id = CODEC_ID_NONE;
3578

    
3579
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3580
    if (!st) {
3581
        fprintf(stderr, "Could not alloc stream\n");
3582
        ffmpeg_exit(1);
3583
    }
3584
    ost = new_output_stream(oc, file_idx);
3585
    subtitle_enc = st->codec;
3586
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3587
    if(!subtitle_stream_copy){
3588
        if (subtitle_codec_name) {
3589
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3590
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3591
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3592
        } else {
3593
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3594
            codec = avcodec_find_encoder(codec_id);
3595
        }
3596
    }
3597
    avcodec_get_context_defaults3(st->codec, codec);
3598

    
3599
    ost->bitstream_filters = subtitle_bitstream_filters;
3600
    subtitle_bitstream_filters= NULL;
3601

    
3602
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3603

    
3604
    if(subtitle_codec_tag)
3605
        subtitle_enc->codec_tag= subtitle_codec_tag;
3606

    
3607
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3608
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3609
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3610
    }
3611
    if (subtitle_stream_copy) {
3612
        st->stream_copy = 1;
3613
    } else {
3614
        subtitle_enc->codec_id = codec_id;
3615
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3616
    }
3617

    
3618
    if (subtitle_language) {
3619
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3620
        av_freep(&subtitle_language);
3621
    }
3622

    
3623
    subtitle_disable = 0;
3624
    av_freep(&subtitle_codec_name);
3625
    subtitle_stream_copy = 0;
3626
}
3627

    
3628
static int opt_new_stream(const char *opt, const char *arg)
3629
{
3630
    AVFormatContext *oc;
3631
    int file_idx = nb_output_files - 1;
3632
    if (nb_output_files <= 0) {
3633
        fprintf(stderr, "At least one output file must be specified\n");
3634
        ffmpeg_exit(1);
3635
    }
3636
    oc = output_files[file_idx];
3637

    
3638
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3639
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3640
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3641
    else av_assert0(0);
3642
    return 0;
3643
}
3644

    
3645
/* arg format is "output-stream-index:streamid-value". */
3646
static int opt_streamid(const char *opt, const char *arg)
3647
{
3648
    int idx;
3649
    char *p;
3650
    char idx_str[16];
3651

    
3652
    strncpy(idx_str, arg, sizeof(idx_str));
3653
    idx_str[sizeof(idx_str)-1] = '\0';
3654
    p = strchr(idx_str, ':');
3655
    if (!p) {
3656
        fprintf(stderr,
3657
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3658
                arg, opt);
3659
        ffmpeg_exit(1);
3660
    }
3661
    *p++ = '\0';
3662
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3663
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3664
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3665
    return 0;
3666
}
3667

    
3668
static void opt_output_file(const char *filename)
3669
{
3670
    AVFormatContext *oc;
3671
    int err, use_video, use_audio, use_subtitle;
3672
    int input_has_video, input_has_audio, input_has_subtitle;
3673
    AVFormatParameters params, *ap = &params;
3674
    AVOutputFormat *file_oformat;
3675

    
3676
    if (!strcmp(filename, "-"))
3677
        filename = "pipe:";
3678

    
3679
    oc = avformat_alloc_context();
3680
    if (!oc) {
3681
        print_error(filename, AVERROR(ENOMEM));
3682
        ffmpeg_exit(1);
3683
    }
3684

    
3685
    if (last_asked_format) {
3686
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3687
        if (!file_oformat) {
3688
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3689
            ffmpeg_exit(1);
3690
        }
3691
        last_asked_format = NULL;
3692
    } else {
3693
        file_oformat = av_guess_format(NULL, filename, NULL);
3694
        if (!file_oformat) {
3695
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3696
                    filename);
3697
            ffmpeg_exit(1);
3698
        }
3699
    }
3700

    
3701
    oc->oformat = file_oformat;
3702
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3703

    
3704
    if (!strcmp(file_oformat->name, "ffm") &&
3705
        av_strstart(filename, "http:", NULL)) {
3706
        /* special case for files sent to ffserver: we get the stream
3707
           parameters from ffserver */
3708
        int err = read_ffserver_streams(oc, filename);
3709
        if (err < 0) {
3710
            print_error(filename, err);
3711
            ffmpeg_exit(1);
3712
        }
3713
    } else {
3714
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3715
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3716
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3717

    
3718
        /* disable if no corresponding type found and at least one
3719
           input file */
3720
        if (nb_input_files > 0) {
3721
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3722
                                         &input_has_subtitle);
3723
            if (!input_has_video)
3724
                use_video = 0;
3725
            if (!input_has_audio)
3726
                use_audio = 0;
3727
            if (!input_has_subtitle)
3728
                use_subtitle = 0;
3729
        }
3730

    
3731
        /* manual disable */
3732
        if (audio_disable)    use_audio    = 0;
3733
        if (video_disable)    use_video    = 0;
3734
        if (subtitle_disable) use_subtitle = 0;
3735

    
3736
        if (use_video)    new_video_stream(oc, nb_output_files);
3737
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3738
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3739

    
3740
        oc->timestamp = recording_timestamp;
3741

    
3742
        av_metadata_copy(&oc->metadata, metadata, 0);
3743
        av_metadata_free(&metadata);
3744
    }
3745

    
3746
    output_files[nb_output_files++] = oc;
3747

    
3748
    /* check filename in case of an image number is expected */
3749
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3750
        if (!av_filename_number_test(oc->filename)) {
3751
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3752
            ffmpeg_exit(1);
3753
        }
3754
    }
3755

    
3756
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3757
        /* test if it already exists to avoid loosing precious files */
3758
        if (!file_overwrite &&
3759
            (strchr(filename, ':') == NULL ||
3760
             filename[1] == ':' ||
3761
             av_strstart(filename, "file:", NULL))) {
3762
            if (url_exist(filename)) {
3763
                if (!using_stdin) {
3764
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3765
                    fflush(stderr);
3766
                    if (!read_yesno()) {
3767
                        fprintf(stderr, "Not overwriting - exiting\n");
3768
                        ffmpeg_exit(1);
3769
                    }
3770
                }
3771
                else {
3772
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3773
                    ffmpeg_exit(1);
3774
                }
3775
            }
3776
        }
3777

    
3778
        /* open the file */
3779
        if ((err = avio_open(&oc->pb, filename, URL_WRONLY)) < 0) {
3780
            print_error(filename, err);
3781
            ffmpeg_exit(1);
3782
        }
3783
    }
3784

    
3785
    memset(ap, 0, sizeof(*ap));
3786
    if (av_set_parameters(oc, ap) < 0) {
3787
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3788
                oc->filename);
3789
        ffmpeg_exit(1);
3790
    }
3791

    
3792
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3793
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3794
    oc->loop_output = loop_output;
3795

    
3796
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3797

    
3798
    av_freep(&forced_key_frames);
3799
}
3800

    
3801
/* same option as mencoder */
3802
static void opt_pass(const char *pass_str)
3803
{
3804
    int pass;
3805
    pass = atoi(pass_str);
3806
    if (pass != 1 && pass != 2) {
3807
        fprintf(stderr, "pass number can be only 1 or 2\n");
3808
        ffmpeg_exit(1);
3809
    }
3810
    do_pass = pass;
3811
}
3812

    
3813
static int64_t getutime(void)
3814
{
3815
#if HAVE_GETRUSAGE
3816
    struct rusage rusage;
3817

    
3818
    getrusage(RUSAGE_SELF, &rusage);
3819
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3820
#elif HAVE_GETPROCESSTIMES
3821
    HANDLE proc;
3822
    FILETIME c, e, k, u;
3823
    proc = GetCurrentProcess();
3824
    GetProcessTimes(proc, &c, &e, &k, &u);
3825
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3826
#else
3827
    return av_gettime();
3828
#endif
3829
}
3830

    
3831
static int64_t getmaxrss(void)
3832
{
3833
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3834
    struct rusage rusage;
3835
    getrusage(RUSAGE_SELF, &rusage);
3836
    return (int64_t)rusage.ru_maxrss * 1024;
3837
#elif HAVE_GETPROCESSMEMORYINFO
3838
    HANDLE proc;
3839
    PROCESS_MEMORY_COUNTERS memcounters;
3840
    proc = GetCurrentProcess();
3841
    memcounters.cb = sizeof(memcounters);
3842
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3843
    return memcounters.PeakPagefileUsage;
3844
#else
3845
    return 0;
3846
#endif
3847
}
3848

    
3849
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3850
{
3851
    int i;
3852
    const char *p = str;
3853
    for(i = 0;; i++) {
3854
        dest[i] = atoi(p);
3855
        if(i == 63)
3856
            break;
3857
        p = strchr(p, ',');
3858
        if(!p) {
3859
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3860
            ffmpeg_exit(1);
3861
        }
3862
        p++;
3863
    }
3864
}
3865

    
3866
static void opt_inter_matrix(const char *arg)
3867
{
3868
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3869
    parse_matrix_coeffs(inter_matrix, arg);
3870
}
3871

    
3872
static void opt_intra_matrix(const char *arg)
3873
{
3874
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3875
    parse_matrix_coeffs(intra_matrix, arg);
3876
}
3877

    
3878
static void show_usage(void)
3879
{
3880
    printf("Hyper fast Audio and Video encoder\n");
3881
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3882
    printf("\n");
3883
}
3884

    
3885
static void show_help(void)
3886
{
3887
    AVCodec *c;
3888
    AVOutputFormat *oformat = NULL;
3889

    
3890
    av_log_set_callback(log_callback_help);
3891
    show_usage();
3892
    show_help_options(options, "Main options:\n",
3893
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3894
    show_help_options(options, "\nAdvanced options:\n",
3895
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3896
                      OPT_EXPERT);
3897
    show_help_options(options, "\nVideo options:\n",
3898
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3899
                      OPT_VIDEO);
3900
    show_help_options(options, "\nAdvanced Video options:\n",
3901
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3902
                      OPT_VIDEO | OPT_EXPERT);
3903
    show_help_options(options, "\nAudio options:\n",
3904
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3905
                      OPT_AUDIO);
3906
    show_help_options(options, "\nAdvanced Audio options:\n",
3907
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3908
                      OPT_AUDIO | OPT_EXPERT);
3909
    show_help_options(options, "\nSubtitle options:\n",
3910
                      OPT_SUBTITLE | OPT_GRAB,
3911
                      OPT_SUBTITLE);
3912
    show_help_options(options, "\nAudio/Video grab options:\n",
3913
                      OPT_GRAB,
3914
                      OPT_GRAB);
3915
    printf("\n");
3916
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3917
    printf("\n");
3918

    
3919
    /* individual codec options */
3920
    c = NULL;
3921
    while ((c = av_codec_next(c))) {
3922
        if (c->priv_class) {
3923
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3924
            printf("\n");
3925
        }
3926
    }
3927

    
3928
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3929
    printf("\n");
3930

    
3931
    /* individual muxer options */
3932
    while ((oformat = av_oformat_next(oformat))) {
3933
        if (oformat->priv_class) {
3934
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3935
            printf("\n");
3936
        }
3937
    }
3938

    
3939
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3940
}
3941

    
3942
static void opt_target(const char *arg)
3943
{
3944
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3945
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3946

    
3947
    if(!strncmp(arg, "pal-", 4)) {
3948
        norm = PAL;
3949
        arg += 4;
3950
    } else if(!strncmp(arg, "ntsc-", 5)) {
3951
        norm = NTSC;
3952
        arg += 5;
3953
    } else if(!strncmp(arg, "film-", 5)) {
3954
        norm = FILM;
3955
        arg += 5;
3956
    } else {
3957
        int fr;
3958
        /* Calculate FR via float to avoid int overflow */
3959
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3960
        if(fr == 25000) {
3961
            norm = PAL;
3962
        } else if((fr == 29970) || (fr == 23976)) {
3963
            norm = NTSC;
3964
        } else {
3965
            /* Try to determine PAL/NTSC by peeking in the input files */
3966
            if(nb_input_files) {
3967
                int i, j;
3968
                for(j = 0; j < nb_input_files; j++) {
3969
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3970
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3971
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3972
                            continue;
3973
                        fr = c->time_base.den * 1000 / c->time_base.num;
3974
                        if(fr == 25000) {
3975
                            norm = PAL;
3976
                            break;
3977
                        } else if((fr == 29970) || (fr == 23976)) {
3978
                            norm = NTSC;
3979
                            break;
3980
                        }
3981
                    }
3982
                    if(norm != UNKNOWN)
3983
                        break;
3984
                }
3985
            }
3986
        }
3987
        if(verbose && norm != UNKNOWN)
3988
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3989
    }
3990

    
3991
    if(norm == UNKNOWN) {
3992
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3993
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3994
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3995
        ffmpeg_exit(1);
3996
    }
3997

    
3998
    if(!strcmp(arg, "vcd")) {
3999

    
4000
        opt_video_codec("mpeg1video");
4001
        opt_audio_codec("mp2");
4002
        opt_format("vcd");
4003

    
4004
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4005
        opt_frame_rate(NULL, frame_rates[norm]);
4006
        opt_default("g", norm == PAL ? "15" : "18");
4007

    
4008
        opt_default("b", "1150000");
4009
        opt_default("maxrate", "1150000");
4010
        opt_default("minrate", "1150000");
4011
        opt_default("bufsize", "327680"); // 40*1024*8;
4012

    
4013
        opt_default("ab", "224000");
4014
        audio_sample_rate = 44100;
4015
        audio_channels = 2;
4016

    
4017
        opt_default("packetsize", "2324");
4018
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4019

    
4020
        /* We have to offset the PTS, so that it is consistent with the SCR.
4021
           SCR starts at 36000, but the first two packs contain only padding
4022
           and the first pack from the other stream, respectively, may also have
4023
           been written before.
4024
           So the real data starts at SCR 36000+3*1200. */
4025
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4026
    } else if(!strcmp(arg, "svcd")) {
4027

    
4028
        opt_video_codec("mpeg2video");
4029
        opt_audio_codec("mp2");
4030
        opt_format("svcd");
4031

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

    
4036
        opt_default("b", "2040000");
4037
        opt_default("maxrate", "2516000");
4038
        opt_default("minrate", "0"); //1145000;
4039
        opt_default("bufsize", "1835008"); //224*1024*8;
4040
        opt_default("flags", "+scan_offset");
4041

    
4042

    
4043
        opt_default("ab", "224000");
4044
        audio_sample_rate = 44100;
4045

    
4046
        opt_default("packetsize", "2324");
4047

    
4048
    } else if(!strcmp(arg, "dvd")) {
4049

    
4050
        opt_video_codec("mpeg2video");
4051
        opt_audio_codec("ac3");
4052
        opt_format("dvd");
4053

    
4054
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4055
        opt_frame_rate(NULL, frame_rates[norm]);
4056
        opt_default("g", norm == PAL ? "15" : "18");
4057

    
4058
        opt_default("b", "6000000");
4059
        opt_default("maxrate", "9000000");
4060
        opt_default("minrate", "0"); //1500000;
4061
        opt_default("bufsize", "1835008"); //224*1024*8;
4062

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

    
4066
        opt_default("ab", "448000");
4067
        audio_sample_rate = 48000;
4068

    
4069
    } else if(!strncmp(arg, "dv", 2)) {
4070

    
4071
        opt_format("dv");
4072

    
4073
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4074
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4075
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4076
        opt_frame_rate(NULL, frame_rates[norm]);
4077

    
4078
        audio_sample_rate = 48000;
4079
        audio_channels = 2;
4080

    
4081
    } else {
4082
        fprintf(stderr, "Unknown target: %s\n", arg);
4083
        ffmpeg_exit(1);
4084
    }
4085
}
4086

    
4087
static void opt_vstats_file (const char *arg)
4088
{
4089
    av_free (vstats_filename);
4090
    vstats_filename=av_strdup (arg);
4091
}
4092

    
4093
static void opt_vstats (void)
4094
{
4095
    char filename[40];
4096
    time_t today2 = time(NULL);
4097
    struct tm *today = localtime(&today2);
4098

    
4099
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4100
             today->tm_sec);
4101
    opt_vstats_file(filename);
4102
}
4103

    
4104
static int opt_bsf(const char *opt, const char *arg)
4105
{
4106
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4107
    AVBitStreamFilterContext **bsfp;
4108

    
4109
    if(!bsfc){
4110
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4111
        ffmpeg_exit(1);
4112
    }
4113

    
4114
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4115
          *opt == 'a' ? &audio_bitstream_filters :
4116
                        &subtitle_bitstream_filters;
4117
    while(*bsfp)
4118
        bsfp= &(*bsfp)->next;
4119

    
4120
    *bsfp= bsfc;
4121

    
4122
    return 0;
4123
}
4124

    
4125
static int opt_preset(const char *opt, const char *arg)
4126
{
4127
    FILE *f=NULL;
4128
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4129
    char *codec_name = *opt == 'v' ? video_codec_name :
4130
                       *opt == 'a' ? audio_codec_name :
4131
                                     subtitle_codec_name;
4132

    
4133
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4134
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4135
        ffmpeg_exit(1);
4136
    }
4137

    
4138
    while(!feof(f)){
4139
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4140
        if(line[0] == '#' && !e)
4141
            continue;
4142
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4143
        if(e){
4144
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4145
            ffmpeg_exit(1);
4146
        }
4147
        if(!strcmp(tmp, "acodec")){
4148
            opt_audio_codec(tmp2);
4149
        }else if(!strcmp(tmp, "vcodec")){
4150
            opt_video_codec(tmp2);
4151
        }else if(!strcmp(tmp, "scodec")){
4152
            opt_subtitle_codec(tmp2);
4153
        }else if(opt_default(tmp, tmp2) < 0){
4154
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4155
            ffmpeg_exit(1);
4156
        }
4157
    }
4158

    
4159
    fclose(f);
4160

    
4161
    return 0;
4162
}
4163

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

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

    
4257
    /* audio options */
4258
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4259
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4260
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4261
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4262
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4263
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4264
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4265
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4266
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4267
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4268
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4269
    { "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" },
4270

    
4271
    /* subtitle options */
4272
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4273
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4274
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4275
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4276
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4277

    
4278
    /* grab options */
4279
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4280
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4281
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4282

    
4283
    /* muxer options */
4284
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4285
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4286

    
4287
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4288
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4289
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4290

    
4291
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4292
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4293
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4294
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4295

    
4296
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4297
    { NULL, },
4298
};
4299

    
4300
int main(int argc, char **argv)
4301
{
4302
    int64_t ti;
4303

    
4304
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4305

    
4306
    avcodec_register_all();
4307
#if CONFIG_AVDEVICE
4308
    avdevice_register_all();
4309
#endif
4310
#if CONFIG_AVFILTER
4311
    avfilter_register_all();
4312
#endif
4313
    av_register_all();
4314

    
4315
#if HAVE_ISATTY
4316
    if(isatty(STDIN_FILENO))
4317
        url_set_interrupt_cb(decode_interrupt_cb);
4318
#endif
4319

    
4320
    init_opts();
4321

    
4322
    show_banner();
4323

    
4324
    /* parse options */
4325
    parse_options(argc, argv, options, opt_output_file);
4326

    
4327
    if(nb_output_files <= 0 && nb_input_files == 0) {
4328
        show_usage();
4329
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4330
        ffmpeg_exit(1);
4331
    }
4332

    
4333
    /* file converter / grab */
4334
    if (nb_output_files <= 0) {
4335
        fprintf(stderr, "At least one output file must be specified\n");
4336
        ffmpeg_exit(1);
4337
    }
4338

    
4339
    if (nb_input_files == 0) {
4340
        fprintf(stderr, "At least one input file must be specified\n");
4341
        ffmpeg_exit(1);
4342
    }
4343

    
4344
    ti = getutime();
4345
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4346
                  stream_maps, nb_stream_maps) < 0)
4347
        ffmpeg_exit(1);
4348
    ti = getutime() - ti;
4349
    if (do_benchmark) {
4350
        int maxrss = getmaxrss() / 1024;
4351
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4352
    }
4353

    
4354
    return ffmpeg_exit(0);
4355
}