Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 0c55c6d3

History | View | Annotate | Download (160 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->audio_service_type = icodec->audio_service_type;
2127
                codec->block_align= icodec->block_align;
2128
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2129
                    codec->block_align= 0;
2130
                if(codec->codec_id == CODEC_ID_AC3)
2131
                    codec->block_align= 0;
2132
                break;
2133
            case AVMEDIA_TYPE_VIDEO:
2134
                codec->pix_fmt = icodec->pix_fmt;
2135
                codec->width = icodec->width;
2136
                codec->height = icodec->height;
2137
                codec->has_b_frames = icodec->has_b_frames;
2138
                break;
2139
            case AVMEDIA_TYPE_SUBTITLE:
2140
                codec->width = icodec->width;
2141
                codec->height = icodec->height;
2142
                break;
2143
            default:
2144
                abort();
2145
            }
2146
        } else {
2147
            switch(codec->codec_type) {
2148
            case AVMEDIA_TYPE_AUDIO:
2149
                ost->fifo= av_fifo_alloc(1024);
2150
                if(!ost->fifo)
2151
                    goto fail;
2152
                ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2153
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2154
                icodec->request_channels = codec->channels;
2155
                ist->decoding_needed = 1;
2156
                ost->encoding_needed = 1;
2157
                ost->resample_sample_fmt  = icodec->sample_fmt;
2158
                ost->resample_sample_rate = icodec->sample_rate;
2159
                ost->resample_channels    = icodec->channels;
2160
                break;
2161
            case AVMEDIA_TYPE_VIDEO:
2162
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2163
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2164
                    ffmpeg_exit(1);
2165
                }
2166
                ost->video_resample = (codec->width != icodec->width   ||
2167
                                       codec->height != icodec->height ||
2168
                        (codec->pix_fmt != icodec->pix_fmt));
2169
                if (ost->video_resample) {
2170
#if !CONFIG_AVFILTER
2171
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2172
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2173
                                         codec->width, codec->height)) {
2174
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2175
                        ffmpeg_exit(1);
2176
                    }
2177
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2178
                    ost->img_resample_ctx = sws_getContext(
2179
                        icodec->width,
2180
                        icodec->height,
2181
                            icodec->pix_fmt,
2182
                            codec->width,
2183
                            codec->height,
2184
                            codec->pix_fmt,
2185
                            sws_flags, NULL, NULL, NULL);
2186
                    if (ost->img_resample_ctx == NULL) {
2187
                        fprintf(stderr, "Cannot get resampling context\n");
2188
                        ffmpeg_exit(1);
2189
                    }
2190

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2473
    timer_start = av_gettime();
2474

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2615
    discard_packet:
2616
        av_free_packet(&pkt);
2617

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

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

    
2630
    term_exit();
2631

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2739
    opt_default(opt, arg);
2740

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

    
2744
    return 0;
2745
}
2746

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

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

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

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

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

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

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

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

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

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

    
2816
    return 0;
2817
}
2818

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

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

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

    
2844
static void opt_audio_sample_fmt(const char *arg)
2845
{
2846
    if (strcmp(arg, "list")) {
2847
        audio_sample_fmt = av_get_sample_fmt(arg);
2848
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2849
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2850
            ffmpeg_exit(1);
2851
        }
2852
    } else {
2853
        int i;
2854
        char fmt_str[128];
2855
        for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2856
            printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2857
        ffmpeg_exit(0);
2858
    }
2859
}
2860

    
2861
static int opt_audio_rate(const char *opt, const char *arg)
2862
{
2863
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2864
    return 0;
2865
}
2866

    
2867
static int opt_audio_channels(const char *opt, const char *arg)
2868
{
2869
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2870
    return 0;
2871
}
2872

    
2873
static void opt_video_channel(const char *arg)
2874
{
2875
    video_channel = strtol(arg, NULL, 0);
2876
}
2877

    
2878
static void opt_video_standard(const char *arg)
2879
{
2880
    video_standard = av_strdup(arg);
2881
}
2882

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

    
2894
static void opt_audio_codec(const char *arg)
2895
{
2896
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2897
}
2898

    
2899
static void opt_video_codec(const char *arg)
2900
{
2901
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2902
}
2903

    
2904
static void opt_subtitle_codec(const char *arg)
2905
{
2906
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2907
}
2908

    
2909
static int opt_codec_tag(const char *opt, const char *arg)
2910
{
2911
    char *tail;
2912
    uint32_t *codec_tag;
2913

    
2914
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2915
                !strcmp(opt, "vtag") ? &video_codec_tag :
2916
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2917
    if (!codec_tag)
2918
        return -1;
2919

    
2920
    *codec_tag = strtol(arg, &tail, 0);
2921
    if (!tail || *tail)
2922
        *codec_tag = AV_RL32(arg);
2923

    
2924
    return 0;
2925
}
2926

    
2927
static void opt_map(const char *arg)
2928
{
2929
    AVStreamMap *m;
2930
    char *p;
2931

    
2932
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2933
    m = &stream_maps[nb_stream_maps-1];
2934

    
2935
    m->file_index = strtol(arg, &p, 0);
2936
    if (*p)
2937
        p++;
2938

    
2939
    m->stream_index = strtol(p, &p, 0);
2940
    if (*p) {
2941
        p++;
2942
        m->sync_file_index = strtol(p, &p, 0);
2943
        if (*p)
2944
            p++;
2945
        m->sync_stream_index = strtol(p, &p, 0);
2946
    } else {
2947
        m->sync_file_index = m->file_index;
2948
        m->sync_stream_index = m->stream_index;
2949
    }
2950
}
2951

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

    
2973
static void opt_map_metadata(const char *arg)
2974
{
2975
    AVMetaDataMap *m, *m1;
2976
    char *p;
2977

    
2978
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2979
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2980

    
2981
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
2982
    m->file = strtol(arg, &p, 0);
2983
    parse_meta_type(p, &m->type, &m->index, &p);
2984
    if (*p)
2985
        p++;
2986

    
2987
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2988
    m1->file = strtol(p, &p, 0);
2989
    parse_meta_type(p, &m1->type, &m1->index, &p);
2990

    
2991
    if (m->type == 'g' || m1->type == 'g')
2992
        metadata_global_autocopy = 0;
2993
    if (m->type == 's' || m1->type == 's')
2994
        metadata_streams_autocopy = 0;
2995
    if (m->type == 'c' || m1->type == 'c')
2996
        metadata_chapters_autocopy = 0;
2997
}
2998

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

    
3006
static void opt_map_chapters(const char *arg)
3007
{
3008
    AVChapterMap *c;
3009
    char *p;
3010

    
3011
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3012
                              nb_chapter_maps + 1);
3013
    c = &chapter_maps[nb_chapter_maps - 1];
3014
    c->out_file = strtol(arg, &p, 0);
3015
    if (*p)
3016
        p++;
3017

    
3018
    c->in_file = strtol(p, &p, 0);
3019
}
3020

    
3021
static void opt_input_ts_scale(const char *arg)
3022
{
3023
    unsigned int stream;
3024
    double scale;
3025
    char *p;
3026

    
3027
    stream = strtol(arg, &p, 0);
3028
    if (*p)
3029
        p++;
3030
    scale= strtod(p, &p);
3031

    
3032
    if(stream >= MAX_STREAMS)
3033
        ffmpeg_exit(1);
3034

    
3035
    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);
3036
    input_files_ts_scale[nb_input_files][stream]= scale;
3037
}
3038

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

    
3045
static int opt_start_time(const char *opt, const char *arg)
3046
{
3047
    start_time = parse_time_or_die(opt, arg, 1);
3048
    return 0;
3049
}
3050

    
3051
static int opt_recording_timestamp(const char *opt, const char *arg)
3052
{
3053
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3054
    return 0;
3055
}
3056

    
3057
static int opt_input_ts_offset(const char *opt, const char *arg)
3058
{
3059
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3060
    return 0;
3061
}
3062

    
3063
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3064
{
3065
    const char *codec_string = encoder ? "encoder" : "decoder";
3066
    AVCodec *codec;
3067

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

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

    
3105
    if (last_asked_format) {
3106
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3107
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3108
            ffmpeg_exit(1);
3109
        }
3110
        last_asked_format = NULL;
3111
    }
3112

    
3113
    if (!strcmp(filename, "-"))
3114
        filename = "pipe:";
3115

    
3116
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3117
                    !strcmp(filename, "/dev/stdin");
3118

    
3119
    /* get default parameters from command line */
3120
    ic = avformat_alloc_context();
3121
    if (!ic) {
3122
        print_error(filename, AVERROR(ENOMEM));
3123
        ffmpeg_exit(1);
3124
    }
3125

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

    
3139
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3140

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

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

    
3182
    ic->loop_input = loop_input;
3183

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

    
3193
    timestamp = start_time;
3194
    /* add the stream start time */
3195
    if (ic->start_time != AV_NOPTS_VALUE)
3196
        timestamp += ic->start_time;
3197

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

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

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

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

    
3261
                    (float)rfps / rfps_base, rfps, rfps_base);
3262
            }
3263
            /* update the current frame rate to match the stream frame rate */
3264
            frame_rate.num = rfps;
3265
            frame_rate.den = rfps_base;
3266

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

    
3287
    input_files[nb_input_files] = ic;
3288
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3289
    /* dump the file content */
3290
    if (verbose >= 0)
3291
        av_dump_format(ic, nb_input_files, filename, 0);
3292

    
3293
    nb_input_files++;
3294

    
3295
    video_channel = 0;
3296

    
3297
    av_freep(&video_codec_name);
3298
    av_freep(&audio_codec_name);
3299
    av_freep(&subtitle_codec_name);
3300
}
3301

    
3302
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3303
                                         int *has_subtitle_ptr)
3304
{
3305
    int has_video, has_audio, has_subtitle, i, j;
3306
    AVFormatContext *ic;
3307

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

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

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

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

    
3374
        ost->avfilter= vfilters;
3375
        vfilters= NULL;
3376
#endif
3377
    }
3378

    
3379
    avcodec_get_context_defaults3(st->codec, codec);
3380
    ost->bitstream_filters = video_bitstream_filters;
3381
    video_bitstream_filters= NULL;
3382

    
3383
    st->codec->thread_count= thread_count;
3384

    
3385
    video_enc = st->codec;
3386

    
3387
    if(video_codec_tag)
3388
        video_enc->codec_tag= video_codec_tag;
3389

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

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

    
3410
        video_enc->codec_id = codec_id;
3411
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3412

    
3413
        if (codec && codec->supported_framerates && !force_fps)
3414
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3415
        video_enc->time_base.den = fps.num;
3416
        video_enc->time_base.num = fps.den;
3417

    
3418
        video_enc->width = frame_width;
3419
        video_enc->height = frame_height;
3420
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3421
        video_enc->pix_fmt = frame_pix_fmt;
3422
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3423

    
3424
        choose_pixel_fmt(st, codec);
3425

    
3426
        if (intra_only)
3427
            video_enc->gop_size = 0;
3428
        if (video_qscale || same_quality) {
3429
            video_enc->flags |= CODEC_FLAG_QSCALE;
3430
            video_enc->global_quality=
3431
                st->quality = FF_QP2LAMBDA * video_qscale;
3432
        }
3433

    
3434
        if(intra_matrix)
3435
            video_enc->intra_matrix = intra_matrix;
3436
        if(inter_matrix)
3437
            video_enc->inter_matrix = inter_matrix;
3438

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

    
3469
        if (do_psnr)
3470
            video_enc->flags|= CODEC_FLAG_PSNR;
3471

    
3472
        /* two pass mode */
3473
        if (do_pass) {
3474
            if (do_pass == 1) {
3475
                video_enc->flags |= CODEC_FLAG_PASS1;
3476
            } else {
3477
                video_enc->flags |= CODEC_FLAG_PASS2;
3478
            }
3479
        }
3480

    
3481
        if (forced_key_frames)
3482
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3483
    }
3484
    if (video_language) {
3485
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3486
        av_freep(&video_language);
3487
    }
3488

    
3489
    /* reset some key parameters */
3490
    video_disable = 0;
3491
    av_freep(&video_codec_name);
3492
    av_freep(&forced_key_frames);
3493
    video_stream_copy = 0;
3494
    frame_pix_fmt = PIX_FMT_NONE;
3495
}
3496

    
3497
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3498
{
3499
    AVStream *st;
3500
    AVOutputStream *ost;
3501
    AVCodec *codec= NULL;
3502
    AVCodecContext *audio_enc;
3503
    enum CodecID codec_id = CODEC_ID_NONE;
3504

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

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

    
3525
    avcodec_get_context_defaults3(st->codec, codec);
3526

    
3527
    ost->bitstream_filters = audio_bitstream_filters;
3528
    audio_bitstream_filters= NULL;
3529

    
3530
    st->codec->thread_count= thread_count;
3531

    
3532
    audio_enc = st->codec;
3533
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3534

    
3535
    if(audio_codec_tag)
3536
        audio_enc->codec_tag= audio_codec_tag;
3537

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

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

    
3569
    /* reset some key parameters */
3570
    audio_disable = 0;
3571
    av_freep(&audio_codec_name);
3572
    audio_stream_copy = 0;
3573
}
3574

    
3575
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3576
{
3577
    AVStream *st;
3578
    AVOutputStream *ost;
3579
    AVCodec *codec=NULL;
3580
    AVCodecContext *subtitle_enc;
3581
    enum CodecID codec_id = CODEC_ID_NONE;
3582

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

    
3603
    ost->bitstream_filters = subtitle_bitstream_filters;
3604
    subtitle_bitstream_filters= NULL;
3605

    
3606
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3607

    
3608
    if(subtitle_codec_tag)
3609
        subtitle_enc->codec_tag= subtitle_codec_tag;
3610

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

    
3622
    if (subtitle_language) {
3623
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3624
        av_freep(&subtitle_language);
3625
    }
3626

    
3627
    subtitle_disable = 0;
3628
    av_freep(&subtitle_codec_name);
3629
    subtitle_stream_copy = 0;
3630
}
3631

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

    
3642
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3643
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3644
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3645
    else av_assert0(0);
3646
    return 0;
3647
}
3648

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

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

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

    
3680
    if (!strcmp(filename, "-"))
3681
        filename = "pipe:";
3682

    
3683
    oc = avformat_alloc_context();
3684
    if (!oc) {
3685
        print_error(filename, AVERROR(ENOMEM));
3686
        ffmpeg_exit(1);
3687
    }
3688

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

    
3705
    oc->oformat = file_oformat;
3706
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3707

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

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

    
3735
        /* manual disable */
3736
        if (audio_disable)    use_audio    = 0;
3737
        if (video_disable)    use_video    = 0;
3738
        if (subtitle_disable) use_subtitle = 0;
3739

    
3740
        if (use_video)    new_video_stream(oc, nb_output_files);
3741
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3742
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3743

    
3744
        oc->timestamp = recording_timestamp;
3745

    
3746
        av_metadata_copy(&oc->metadata, metadata, 0);
3747
        av_metadata_free(&metadata);
3748
    }
3749

    
3750
    output_files[nb_output_files++] = oc;
3751

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

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

    
3782
        /* open the file */
3783
        if ((err = avio_open(&oc->pb, filename, URL_WRONLY)) < 0) {
3784
            print_error(filename, err);
3785
            ffmpeg_exit(1);
3786
        }
3787
    }
3788

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

    
3796
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3797
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3798
    oc->loop_output = loop_output;
3799

    
3800
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3801

    
3802
    av_freep(&forced_key_frames);
3803
}
3804

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

    
3817
static int64_t getutime(void)
3818
{
3819
#if HAVE_GETRUSAGE
3820
    struct rusage rusage;
3821

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

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

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

    
3870
static void opt_inter_matrix(const char *arg)
3871
{
3872
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3873
    parse_matrix_coeffs(inter_matrix, arg);
3874
}
3875

    
3876
static void opt_intra_matrix(const char *arg)
3877
{
3878
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3879
    parse_matrix_coeffs(intra_matrix, arg);
3880
}
3881

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

    
3889
static void show_help(void)
3890
{
3891
    AVCodec *c;
3892
    AVOutputFormat *oformat = NULL;
3893

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

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

    
3932
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3933
    printf("\n");
3934

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

    
3943
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3944
}
3945

    
3946
static void opt_target(const char *arg)
3947
{
3948
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3949
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3950

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

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

    
4002
    if(!strcmp(arg, "vcd")) {
4003

    
4004
        opt_video_codec("mpeg1video");
4005
        opt_audio_codec("mp2");
4006
        opt_format("vcd");
4007

    
4008
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4009
        opt_frame_rate(NULL, frame_rates[norm]);
4010
        opt_default("g", norm == PAL ? "15" : "18");
4011

    
4012
        opt_default("b", "1150000");
4013
        opt_default("maxrate", "1150000");
4014
        opt_default("minrate", "1150000");
4015
        opt_default("bufsize", "327680"); // 40*1024*8;
4016

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

    
4021
        opt_default("packetsize", "2324");
4022
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4023

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

    
4032
        opt_video_codec("mpeg2video");
4033
        opt_audio_codec("mp2");
4034
        opt_format("svcd");
4035

    
4036
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4037
        opt_frame_rate(NULL, frame_rates[norm]);
4038
        opt_default("g", norm == PAL ? "15" : "18");
4039

    
4040
        opt_default("b", "2040000");
4041
        opt_default("maxrate", "2516000");
4042
        opt_default("minrate", "0"); //1145000;
4043
        opt_default("bufsize", "1835008"); //224*1024*8;
4044
        opt_default("flags", "+scan_offset");
4045

    
4046

    
4047
        opt_default("ab", "224000");
4048
        audio_sample_rate = 44100;
4049

    
4050
        opt_default("packetsize", "2324");
4051

    
4052
    } else if(!strcmp(arg, "dvd")) {
4053

    
4054
        opt_video_codec("mpeg2video");
4055
        opt_audio_codec("ac3");
4056
        opt_format("dvd");
4057

    
4058
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4059
        opt_frame_rate(NULL, frame_rates[norm]);
4060
        opt_default("g", norm == PAL ? "15" : "18");
4061

    
4062
        opt_default("b", "6000000");
4063
        opt_default("maxrate", "9000000");
4064
        opt_default("minrate", "0"); //1500000;
4065
        opt_default("bufsize", "1835008"); //224*1024*8;
4066

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

    
4070
        opt_default("ab", "448000");
4071
        audio_sample_rate = 48000;
4072

    
4073
    } else if(!strncmp(arg, "dv", 2)) {
4074

    
4075
        opt_format("dv");
4076

    
4077
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4078
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4079
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4080
        opt_frame_rate(NULL, frame_rates[norm]);
4081

    
4082
        audio_sample_rate = 48000;
4083
        audio_channels = 2;
4084

    
4085
    } else {
4086
        fprintf(stderr, "Unknown target: %s\n", arg);
4087
        ffmpeg_exit(1);
4088
    }
4089
}
4090

    
4091
static void opt_vstats_file (const char *arg)
4092
{
4093
    av_free (vstats_filename);
4094
    vstats_filename=av_strdup (arg);
4095
}
4096

    
4097
static void opt_vstats (void)
4098
{
4099
    char filename[40];
4100
    time_t today2 = time(NULL);
4101
    struct tm *today = localtime(&today2);
4102

    
4103
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4104
             today->tm_sec);
4105
    opt_vstats_file(filename);
4106
}
4107

    
4108
static int opt_bsf(const char *opt, const char *arg)
4109
{
4110
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4111
    AVBitStreamFilterContext **bsfp;
4112

    
4113
    if(!bsfc){
4114
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4115
        ffmpeg_exit(1);
4116
    }
4117

    
4118
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4119
          *opt == 'a' ? &audio_bitstream_filters :
4120
                        &subtitle_bitstream_filters;
4121
    while(*bsfp)
4122
        bsfp= &(*bsfp)->next;
4123

    
4124
    *bsfp= bsfc;
4125

    
4126
    return 0;
4127
}
4128

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

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

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

    
4163
    fclose(f);
4164

    
4165
    return 0;
4166
}
4167

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

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

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

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

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

    
4287
    /* muxer options */
4288
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4289
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4290

    
4291
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4292
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4293
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4294

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

    
4300
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4301
    { NULL, },
4302
};
4303

    
4304
int main(int argc, char **argv)
4305
{
4306
    int64_t ti;
4307

    
4308
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4309

    
4310
    avcodec_register_all();
4311
#if CONFIG_AVDEVICE
4312
    avdevice_register_all();
4313
#endif
4314
#if CONFIG_AVFILTER
4315
    avfilter_register_all();
4316
#endif
4317
    av_register_all();
4318

    
4319
#if HAVE_ISATTY
4320
    if(isatty(STDIN_FILENO))
4321
        url_set_interrupt_cb(decode_interrupt_cb);
4322
#endif
4323

    
4324
    init_opts();
4325

    
4326
    show_banner();
4327

    
4328
    /* parse options */
4329
    parse_options(argc, argv, options, opt_output_file);
4330

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

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

    
4343
    if (nb_input_files == 0) {
4344
        fprintf(stderr, "At least one input file must be specified\n");
4345
        ffmpeg_exit(1);
4346
    }
4347

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

    
4358
    return ffmpeg_exit(0);
4359
}