Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ b58b9fa3

History | View | Annotate | Download (158 KB)

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

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

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

    
50
#if CONFIG_AVFILTER
51
# include "libavfilter/avfilter.h"
52
# include "libavfilter/avfiltergraph.h"
53
# include "libavfilter/vsrc_buffer.h"
54
#endif
55

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

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

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

    
77
#include "cmdutils.h"
78

    
79
#include "libavutil/avassert.h"
80

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

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

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

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

    
106
static const OptionDef options[];
107

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

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

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

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

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

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

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

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

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

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

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

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

    
219
static int rate_emu = 0;
220

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

    
224
static int audio_volume = 256;
225

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

    
241
static float dts_delta_threshold = 10;
242

    
243
static unsigned int sws_flags = SWS_BICUBIC;
244

    
245
static int64_t timer_start;
246

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

    
251
static short *samples;
252

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

    
257
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
258

    
259
struct AVInputStream;
260

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

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

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

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

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

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

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

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

    
338
#if CONFIG_AVFILTER
339

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

    
350
    graph = avfilter_graph_alloc();
351

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

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

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

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

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

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

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

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

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

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

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

    
417
static volatile int received_sigterm = 0;
418

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

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

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

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

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

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

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

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

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

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

    
484
    av_free(video_standard);
485

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

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

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

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

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

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

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

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

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

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

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

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

    
622
        s->nb_streams++;
623

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

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

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

    
651
        new_output_stream(s, nb_output_files);
652
    }
653

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

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

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

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

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

    
690
        bsfc= bsfc->next;
691
    }
692

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

    
700
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
701

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1073
    *frame_size = 0;
1074

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

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

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

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

    
1113
        fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width,     ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1114
        if(!ost->video_resample)
1115
            ffmpeg_exit(1);
1116
    }
1117

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1297

    
1298
    oc = output_files[0];
1299

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

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

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

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

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

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

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

    
1378
        fflush(stderr);
1379
    }
1380

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

    
1393
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1394
static int output_packet(AVInputStream *ist, int ist_index,
1395
                         AVOutputStream **ost_table, int nb_ostreams,
1396
                         const AVPacket *pkt)
1397
{
1398
    AVFormatContext *os;
1399
    AVOutputStream *ost;
1400
    int ret, i;
1401
    int got_picture;
1402
    AVFrame picture;
1403
    void *buffer_to_free;
1404
    static unsigned int samples_size= 0;
1405
    AVSubtitle subtitle, *subtitle_to_free;
1406
    int64_t pkt_pts = AV_NOPTS_VALUE;
1407
#if CONFIG_AVFILTER
1408
    int frame_available;
1409
#endif
1410

    
1411
    AVPacket avpkt;
1412
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1413

    
1414
    if(ist->next_pts == AV_NOPTS_VALUE)
1415
        ist->next_pts= ist->pts;
1416

    
1417
    if (pkt == NULL) {
1418
        /* EOF handling */
1419
        av_init_packet(&avpkt);
1420
        avpkt.data = NULL;
1421
        avpkt.size = 0;
1422
        goto handle_eof;
1423
    } else {
1424
        avpkt = *pkt;
1425
    }
1426

    
1427
    if(pkt->dts != AV_NOPTS_VALUE)
1428
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1429
    if(pkt->pts != AV_NOPTS_VALUE)
1430
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1431

    
1432
    //while we have more to decode or while the decoder did output something on EOF
1433
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1434
        uint8_t *data_buf, *decoded_data_buf;
1435
        int data_size, decoded_data_size;
1436
    handle_eof:
1437
        ist->pts= ist->next_pts;
1438

    
1439
        if(avpkt.size && avpkt.size != pkt->size &&
1440
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1441
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1442
            ist->showed_multi_packet_warning=1;
1443
        }
1444

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

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

    
1538
        buffer_to_free = NULL;
1539
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1540
            pre_process_video_frame(ist, (AVPicture *)&picture,
1541
                                    &buffer_to_free);
1542
        }
1543

    
1544
#if CONFIG_AVFILTER
1545
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1546
            AVRational sar;
1547
            if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1548
            else                                  sar = ist->st->codec->sample_aspect_ratio;
1549
            // add it to be filtered
1550
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1551
                                     ist->pts,
1552
                                     sar);
1553
        }
1554
#endif
1555

    
1556
        // preprocess audio (volume)
1557
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1558
            if (audio_volume != 256) {
1559
                short *volp;
1560
                volp = samples;
1561
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1562
                    int v = ((*volp) * audio_volume + 128) >> 8;
1563
                    if (v < -32768) v = -32768;
1564
                    if (v >  32767) v = 32767;
1565
                    *volp++ = v;
1566
                }
1567
            }
1568
        }
1569

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

    
1595
                ost = ost_table[i];
1596
                if (ost->source_index == ist_index) {
1597
                    os = output_files[ost->file_index];
1598

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

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

    
1629
                        av_init_packet(&opkt);
1630

    
1631
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1632
                            continue;
1633

    
1634
                        /* no reencoding needed : output the packet directly */
1635
                        /* force the input stream PTS */
1636

    
1637
                        avcodec_get_frame_defaults(&avframe);
1638
                        ost->st->codec->coded_frame= &avframe;
1639
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1640

    
1641
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1642
                            audio_size += data_size;
1643
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1644
                            video_size += data_size;
1645
                            ost->sync_opts++;
1646
                        }
1647

    
1648
                        opkt.stream_index= ost->index;
1649
                        if(pkt->pts != AV_NOPTS_VALUE)
1650
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1651
                        else
1652
                            opkt.pts= AV_NOPTS_VALUE;
1653

    
1654
                        if (pkt->dts == AV_NOPTS_VALUE)
1655
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1656
                        else
1657
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1658
                        opkt.dts -= ost_tb_start_time;
1659

    
1660
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1661
                        opkt.flags= pkt->flags;
1662

    
1663
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1664
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1665
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1666
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1667
                           ) {
1668
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1669
                                opkt.destruct= av_destruct_packet;
1670
                        } else {
1671
                            opkt.data = data_buf;
1672
                            opkt.size = data_size;
1673
                        }
1674

    
1675
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1676
                        ost->st->codec->frame_number++;
1677
                        ost->frame_number++;
1678
                        av_free_packet(&opkt);
1679
                    }
1680
                }
1681
            }
1682

    
1683
#if CONFIG_AVFILTER
1684
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1685
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1686
            if(ist->picref)
1687
                avfilter_unref_buffer(ist->picref);
1688
        }
1689
#endif
1690
        av_free(buffer_to_free);
1691
        /* XXX: allocate the subtitles in the codec ? */
1692
        if (subtitle_to_free) {
1693
            avsubtitle_free(subtitle_to_free);
1694
            subtitle_to_free = NULL;
1695
        }
1696
    }
1697
 discard_packet:
1698
    if (pkt == NULL) {
1699
        /* EOF handling */
1700

    
1701
        for(i=0;i<nb_ostreams;i++) {
1702
            ost = ost_table[i];
1703
            if (ost->source_index == ist_index) {
1704
                AVCodecContext *enc= ost->st->codec;
1705
                os = output_files[ost->file_index];
1706

    
1707
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1708
                    continue;
1709
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1710
                    continue;
1711

    
1712
                if (ost->encoding_needed) {
1713
                    for(;;) {
1714
                        AVPacket pkt;
1715
                        int fifo_bytes;
1716
                        av_init_packet(&pkt);
1717
                        pkt.stream_index= ost->index;
1718

    
1719
                        switch(ost->st->codec->codec_type) {
1720
                        case AVMEDIA_TYPE_AUDIO:
1721
                            fifo_bytes = av_fifo_size(ost->fifo);
1722
                            ret = 0;
1723
                            /* encode any samples remaining in fifo */
1724
                            if (fifo_bytes > 0) {
1725
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1726
                                int fs_tmp = enc->frame_size;
1727

    
1728
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1729
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1730
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1731
                                } else { /* pad */
1732
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1733
                                    if (allocated_audio_buf_size < frame_bytes)
1734
                                        ffmpeg_exit(1);
1735
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1736
                                }
1737

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

    
1770
                        if(ret<=0)
1771
                            break;
1772
                        pkt.data= bit_buffer;
1773
                        pkt.size= ret;
1774
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1775
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1776
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1777
                    }
1778
                }
1779
            }
1780
        }
1781
    }
1782

    
1783
    return 0;
1784
 fail_decode:
1785
    return -1;
1786
}
1787

    
1788
static void print_sdp(AVFormatContext **avc, int n)
1789
{
1790
    char sdp[2048];
1791

    
1792
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1793
    printf("SDP:\n%s\n", sdp);
1794
    fflush(stdout);
1795
}
1796

    
1797
static int copy_chapters(int infile, int outfile)
1798
{
1799
    AVFormatContext *is = input_files[infile];
1800
    AVFormatContext *os = output_files[outfile];
1801
    int i;
1802

    
1803
    for (i = 0; i < is->nb_chapters; i++) {
1804
        AVChapter *in_ch = is->chapters[i], *out_ch;
1805
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1806
                                      AV_TIME_BASE_Q, in_ch->time_base);
1807
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1808
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1809

    
1810

    
1811
        if (in_ch->end < ts_off)
1812
            continue;
1813
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1814
            break;
1815

    
1816
        out_ch = av_mallocz(sizeof(AVChapter));
1817
        if (!out_ch)
1818
            return AVERROR(ENOMEM);
1819

    
1820
        out_ch->id        = in_ch->id;
1821
        out_ch->time_base = in_ch->time_base;
1822
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1823
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1824

    
1825
        if (metadata_chapters_autocopy)
1826
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1827

    
1828
        os->nb_chapters++;
1829
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1830
        if (!os->chapters)
1831
            return AVERROR(ENOMEM);
1832
        os->chapters[os->nb_chapters - 1] = out_ch;
1833
    }
1834
    return 0;
1835
}
1836

    
1837
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1838
                                    AVCodecContext *avctx)
1839
{
1840
    char *p;
1841
    int n = 1, i;
1842
    int64_t t;
1843

    
1844
    for (p = kf; *p; p++)
1845
        if (*p == ',')
1846
            n++;
1847
    ost->forced_kf_count = n;
1848
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1849
    if (!ost->forced_kf_pts) {
1850
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1851
        ffmpeg_exit(1);
1852
    }
1853
    for (i = 0; i < n; i++) {
1854
        p = i ? strchr(p, ',') + 1 : kf;
1855
        t = parse_time_or_die("force_key_frames", p, 1);
1856
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1857
    }
1858
}
1859

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

    
1881
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1882
    if (!file_table)
1883
        goto fail;
1884

    
1885
    /* input stream init */
1886
    j = 0;
1887
    for(i=0;i<nb_input_files;i++) {
1888
        is = input_files[i];
1889
        file_table[i].ist_index = j;
1890
        file_table[i].nb_streams = is->nb_streams;
1891
        j += is->nb_streams;
1892
    }
1893
    nb_istreams = j;
1894

    
1895
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1896
    if (!ist_table)
1897
        goto fail;
1898

    
1899
    for(i=0;i<nb_istreams;i++) {
1900
        ist = av_mallocz(sizeof(AVInputStream));
1901
        if (!ist)
1902
            goto fail;
1903
        ist_table[i] = ist;
1904
    }
1905
    j = 0;
1906
    for(i=0;i<nb_input_files;i++) {
1907
        is = input_files[i];
1908
        for(k=0;k<is->nb_streams;k++) {
1909
            ist = ist_table[j++];
1910
            ist->st = is->streams[k];
1911
            ist->file_index = i;
1912
            ist->index = k;
1913
            ist->discard = 1; /* the stream is discarded by default
1914
                                 (changed later) */
1915

    
1916
            if (rate_emu) {
1917
                ist->start = av_gettime();
1918
            }
1919
        }
1920
    }
1921

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

    
1940
    /* Sanity check the mapping args -- do the input files & streams exist? */
1941
    for(i=0;i<nb_stream_maps;i++) {
1942
        int fi = stream_maps[i].file_index;
1943
        int si = stream_maps[i].stream_index;
1944

    
1945
        if (fi < 0 || fi > nb_input_files - 1 ||
1946
            si < 0 || si > file_table[fi].nb_streams - 1) {
1947
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1948
            ret = AVERROR(EINVAL);
1949
            goto fail;
1950
        }
1951
        fi = stream_maps[i].sync_file_index;
1952
        si = stream_maps[i].sync_stream_index;
1953
        if (fi < 0 || fi > nb_input_files - 1 ||
1954
            si < 0 || si > file_table[fi].nb_streams - 1) {
1955
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1956
            ret = AVERROR(EINVAL);
1957
            goto fail;
1958
        }
1959
    }
1960

    
1961
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1962
    if (!ost_table)
1963
        goto fail;
1964
    n = 0;
1965
    for(k=0;k<nb_output_files;k++) {
1966
        os = output_files[k];
1967
        for(i=0;i<os->nb_streams;i++,n++) {
1968
            int found;
1969
            ost = ost_table[n] = output_streams_for_file[k][i];
1970
            ost->st = os->streams[i];
1971
            if (nb_stream_maps > 0) {
1972
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1973
                    stream_maps[n].stream_index;
1974

    
1975
                /* Sanity check that the stream types match */
1976
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1977
                    int i= ost->file_index;
1978
                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1979
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1980
                        stream_maps[n].file_index, stream_maps[n].stream_index,
1981
                        ost->file_index, ost->index);
1982
                    ffmpeg_exit(1);
1983
                }
1984

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

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

    
2044
    /* for each output stream, we compute the right encoding parameters */
2045
    for(i=0;i<nb_ostreams;i++) {
2046
        ost = ost_table[i];
2047
        os = output_files[ost->file_index];
2048
        ist = ist_table[ost->source_index];
2049

    
2050
        codec = ost->st->codec;
2051
        icodec = ist->st->codec;
2052

    
2053
        if (metadata_streams_autocopy)
2054
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2055
                             AV_METADATA_DONT_OVERWRITE);
2056

    
2057
        ost->st->disposition = ist->st->disposition;
2058
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2059
        codec->chroma_sample_location = icodec->chroma_sample_location;
2060

    
2061
        if (ost->st->stream_copy) {
2062
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2063

    
2064
            if (extra_size > INT_MAX)
2065
                goto fail;
2066

    
2067
            /* if stream_copy is selected, no need to decode or encode */
2068
            codec->codec_id = icodec->codec_id;
2069
            codec->codec_type = icodec->codec_type;
2070

    
2071
            if(!codec->codec_tag){
2072
                if(   !os->oformat->codec_tag
2073
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2074
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2075
                    codec->codec_tag = icodec->codec_tag;
2076
            }
2077

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

    
2167
                    ost->original_height = icodec->height;
2168
                    ost->original_width  = icodec->width;
2169
#endif
2170
                    codec->bits_per_raw_sample= 0;
2171
                }
2172
                ost->resample_height = icodec->height;
2173
                ost->resample_width  = icodec->width;
2174
                ost->resample_pix_fmt= icodec->pix_fmt;
2175
                ost->encoding_needed = 1;
2176
                ist->decoding_needed = 1;
2177

    
2178
#if CONFIG_AVFILTER
2179
                if (configure_filters(ist, ost)) {
2180
                    fprintf(stderr, "Error opening filters!\n");
2181
                    exit(1);
2182
                }
2183
#endif
2184
                break;
2185
            case AVMEDIA_TYPE_SUBTITLE:
2186
                ost->encoding_needed = 1;
2187
                ist->decoding_needed = 1;
2188
                break;
2189
            default:
2190
                abort();
2191
                break;
2192
            }
2193
            /* two pass mode */
2194
            if (ost->encoding_needed &&
2195
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2196
                char logfilename[1024];
2197
                FILE *f;
2198

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

    
2226
    if (!bit_buffer)
2227
        bit_buffer = av_malloc(bit_buffer_size);
2228
    if (!bit_buffer) {
2229
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2230
                bit_buffer_size);
2231
        ret = AVERROR(ENOMEM);
2232
        goto fail;
2233
    }
2234

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

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

    
2292
    /* init pts */
2293
    for(i=0;i<nb_istreams;i++) {
2294
        AVStream *st;
2295
        ist = ist_table[i];
2296
        st= ist->st;
2297
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2298
        ist->next_pts = AV_NOPTS_VALUE;
2299
        init_pts_correction(&ist->pts_ctx);
2300
        ist->is_start = 1;
2301
    }
2302

    
2303
    /* set meta data information from input file if required */
2304
    for (i=0;i<nb_meta_data_maps;i++) {
2305
        AVFormatContext *files[2];
2306
        AVMetadata      **meta[2];
2307
        int j;
2308

    
2309
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2310
        if ((index) < 0 || (index) >= (nb_elems)) {\
2311
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2312
                     (desc), (index));\
2313
            ret = AVERROR(EINVAL);\
2314
            goto dump_format;\
2315
        }
2316

    
2317
        int out_file_index = meta_data_maps[i][0].file;
2318
        int in_file_index = meta_data_maps[i][1].file;
2319
        if (in_file_index < 0 || out_file_index < 0)
2320
            continue;
2321
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2322
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2323

    
2324
        files[0] = output_files[out_file_index];
2325
        files[1] = input_files[in_file_index];
2326

    
2327
        for (j = 0; j < 2; j++) {
2328
            AVMetaDataMap *map = &meta_data_maps[i][j];
2329

    
2330
            switch (map->type) {
2331
            case 'g':
2332
                meta[j] = &files[j]->metadata;
2333
                break;
2334
            case 's':
2335
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2336
                meta[j] = &files[j]->streams[map->index]->metadata;
2337
                break;
2338
            case 'c':
2339
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2340
                meta[j] = &files[j]->chapters[map->index]->metadata;
2341
                break;
2342
            case 'p':
2343
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2344
                meta[j] = &files[j]->programs[map->index]->metadata;
2345
                break;
2346
            }
2347
        }
2348

    
2349
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2350
    }
2351

    
2352
    /* copy global metadata by default */
2353
    if (metadata_global_autocopy) {
2354

    
2355
        for (i = 0; i < nb_output_files; i++)
2356
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2357
                             AV_METADATA_DONT_OVERWRITE);
2358
    }
2359

    
2360
    /* copy chapters according to chapter maps */
2361
    for (i = 0; i < nb_chapter_maps; i++) {
2362
        int infile  = chapter_maps[i].in_file;
2363
        int outfile = chapter_maps[i].out_file;
2364

    
2365
        if (infile < 0 || outfile < 0)
2366
            continue;
2367
        if (infile >= nb_input_files) {
2368
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2369
            ret = AVERROR(EINVAL);
2370
            goto dump_format;
2371
        }
2372
        if (outfile >= nb_output_files) {
2373
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2374
            ret = AVERROR(EINVAL);
2375
            goto dump_format;
2376
        }
2377
        copy_chapters(infile, outfile);
2378
    }
2379

    
2380
    /* copy chapters from the first input file that has them*/
2381
    if (!nb_chapter_maps)
2382
        for (i = 0; i < nb_input_files; i++) {
2383
            if (!input_files[i]->nb_chapters)
2384
                continue;
2385

    
2386
            for (j = 0; j < nb_output_files; j++)
2387
                if ((ret = copy_chapters(i, j)) < 0)
2388
                    goto dump_format;
2389
            break;
2390
        }
2391

    
2392
    /* open files and write file headers */
2393
    for(i=0;i<nb_output_files;i++) {
2394
        os = output_files[i];
2395
        if (av_write_header(os) < 0) {
2396
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2397
            ret = AVERROR(EINVAL);
2398
            goto dump_format;
2399
        }
2400
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2401
            want_sdp = 0;
2402
        }
2403
    }
2404

    
2405
 dump_format:
2406
    /* dump the file output parameters - cannot be done before in case
2407
       of stream copy */
2408
    for(i=0;i<nb_output_files;i++) {
2409
        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2410
    }
2411

    
2412
    /* dump the stream mapping */
2413
    if (verbose >= 0) {
2414
        fprintf(stderr, "Stream mapping:\n");
2415
        for(i=0;i<nb_ostreams;i++) {
2416
            ost = ost_table[i];
2417
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2418
                    ist_table[ost->source_index]->file_index,
2419
                    ist_table[ost->source_index]->index,
2420
                    ost->file_index,
2421
                    ost->index);
2422
            if (ost->sync_ist != ist_table[ost->source_index])
2423
                fprintf(stderr, " [sync #%d.%d]",
2424
                        ost->sync_ist->file_index,
2425
                        ost->sync_ist->index);
2426
            fprintf(stderr, "\n");
2427
        }
2428
    }
2429

    
2430
    if (ret) {
2431
        fprintf(stderr, "%s\n", error);
2432
        goto fail;
2433
    }
2434

    
2435
    if (want_sdp) {
2436
        print_sdp(output_files, nb_output_files);
2437
    }
2438

    
2439
    if (!using_stdin && verbose >= 0) {
2440
#if HAVE_KBHIT
2441
        fprintf(stderr, "Press [q] to stop encoding\n");
2442
#else
2443
        fprintf(stderr, "Press ctrl-c to stop encoding\n");
2444
#endif
2445
        url_set_interrupt_cb(decode_interrupt_cb);
2446
    }
2447
    term_init();
2448

    
2449
    timer_start = av_gettime();
2450

    
2451
    for(; received_sigterm == 0;) {
2452
        int file_index, ist_index;
2453
        AVPacket pkt;
2454
        double ipts_min;
2455
        double opts_min;
2456

    
2457
    redo:
2458
        ipts_min= 1e100;
2459
        opts_min= 1e100;
2460
        /* if 'q' pressed, exits */
2461
        if (!using_stdin) {
2462
            if (q_pressed)
2463
                break;
2464
            /* read_key() returns 0 on EOF */
2465
            key = read_key();
2466
            if (key == 'q')
2467
                break;
2468
        }
2469

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

    
2508
        /* finish if limit size exhausted */
2509
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2510
            break;
2511

    
2512
        /* read a frame from it and output it in the fifo */
2513
        is = input_files[file_index];
2514
        ret= av_read_frame(is, &pkt);
2515
        if(ret == AVERROR(EAGAIN)){
2516
            no_packet[file_index]=1;
2517
            no_packet_count++;
2518
            continue;
2519
        }
2520
        if (ret < 0) {
2521
            file_table[file_index].eof_reached = 1;
2522
            if (opt_shortest)
2523
                break;
2524
            else
2525
                continue;
2526
        }
2527

    
2528
        no_packet_count=0;
2529
        memset(no_packet, 0, sizeof(no_packet));
2530

    
2531
        if (do_pkt_dump) {
2532
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2533
                             is->streams[pkt.stream_index]);
2534
        }
2535
        /* the following test is needed in case new streams appear
2536
           dynamically in stream : we ignore them */
2537
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2538
            goto discard_packet;
2539
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2540
        ist = ist_table[ist_index];
2541
        if (ist->discard)
2542
            goto discard_packet;
2543

    
2544
        if (pkt.dts != AV_NOPTS_VALUE)
2545
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2546
        if (pkt.pts != AV_NOPTS_VALUE)
2547
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2548

    
2549
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2550
            && input_files_ts_scale[file_index][pkt.stream_index]){
2551
            if(pkt.pts != AV_NOPTS_VALUE)
2552
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2553
            if(pkt.dts != AV_NOPTS_VALUE)
2554
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2555
        }
2556

    
2557
//        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);
2558
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2559
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2560
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2561
            int64_t delta= pkt_dts - ist->next_pts;
2562
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2563
                input_files_ts_offset[ist->file_index]-= delta;
2564
                if (verbose > 2)
2565
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2566
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2567
                if(pkt.pts != AV_NOPTS_VALUE)
2568
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2569
            }
2570
        }
2571

    
2572
        /* finish if recording time exhausted */
2573
        if (recording_time != INT64_MAX &&
2574
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2575
            ist->is_past_recording_time = 1;
2576
            goto discard_packet;
2577
        }
2578

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

    
2582
            if (verbose >= 0)
2583
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2584
                        ist->file_index, ist->index);
2585
            if (exit_on_error)
2586
                ffmpeg_exit(1);
2587
            av_free_packet(&pkt);
2588
            goto redo;
2589
        }
2590

    
2591
    discard_packet:
2592
        av_free_packet(&pkt);
2593

    
2594
        /* dump report by using the output first video and audio streams */
2595
        print_report(output_files, ost_table, nb_ostreams, 0);
2596
    }
2597

    
2598
    /* at the end of stream, we must flush the decoder buffers */
2599
    for(i=0;i<nb_istreams;i++) {
2600
        ist = ist_table[i];
2601
        if (ist->decoding_needed) {
2602
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2603
        }
2604
    }
2605

    
2606
    term_exit();
2607

    
2608
    /* write the trailer if needed and close file */
2609
    for(i=0;i<nb_output_files;i++) {
2610
        os = output_files[i];
2611
        av_write_trailer(os);
2612
    }
2613

    
2614
    /* dump report by using the first video and audio streams */
2615
    print_report(output_files, ost_table, nb_ostreams, 1);
2616

    
2617
    /* close each encoder */
2618
    for(i=0;i<nb_ostreams;i++) {
2619
        ost = ost_table[i];
2620
        if (ost->encoding_needed) {
2621
            av_freep(&ost->st->codec->stats_in);
2622
            avcodec_close(ost->st->codec);
2623
        }
2624
    }
2625

    
2626
    /* close each decoder */
2627
    for(i=0;i<nb_istreams;i++) {
2628
        ist = ist_table[i];
2629
        if (ist->decoding_needed) {
2630
            avcodec_close(ist->st->codec);
2631
        }
2632
    }
2633
#if CONFIG_AVFILTER
2634
    avfilter_graph_free(&graph);
2635
#endif
2636

    
2637
    /* finished ! */
2638
    ret = 0;
2639

    
2640
 fail:
2641
    av_freep(&bit_buffer);
2642
    av_free(file_table);
2643

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

    
2680
static void opt_format(const char *arg)
2681
{
2682
    last_asked_format = arg;
2683
}
2684

    
2685
static void opt_video_rc_override_string(const char *arg)
2686
{
2687
    video_rc_override_string = arg;
2688
}
2689

    
2690
static int opt_me_threshold(const char *opt, const char *arg)
2691
{
2692
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2693
    return 0;
2694
}
2695

    
2696
static int opt_verbose(const char *opt, const char *arg)
2697
{
2698
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2699
    return 0;
2700
}
2701

    
2702
static int opt_frame_rate(const char *opt, const char *arg)
2703
{
2704
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2705
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2706
        ffmpeg_exit(1);
2707
    }
2708
    return 0;
2709
}
2710

    
2711
static int opt_bitrate(const char *opt, const char *arg)
2712
{
2713
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2714

    
2715
    opt_default(opt, arg);
2716

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

    
2720
    return 0;
2721
}
2722

    
2723
static int opt_frame_crop(const char *opt, const char *arg)
2724
{
2725
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2726
    return AVERROR(EINVAL);
2727
}
2728

    
2729
static void opt_frame_size(const char *arg)
2730
{
2731
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2732
        fprintf(stderr, "Incorrect frame size\n");
2733
        ffmpeg_exit(1);
2734
    }
2735
}
2736

    
2737
static int opt_pad(const char *opt, const char *arg) {
2738
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2739
    return -1;
2740
}
2741

    
2742
static void opt_frame_pix_fmt(const char *arg)
2743
{
2744
    if (strcmp(arg, "list")) {
2745
        frame_pix_fmt = av_get_pix_fmt(arg);
2746
        if (frame_pix_fmt == PIX_FMT_NONE) {
2747
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2748
            ffmpeg_exit(1);
2749
        }
2750
    } else {
2751
        show_pix_fmts();
2752
        ffmpeg_exit(0);
2753
    }
2754
}
2755

    
2756
static void opt_frame_aspect_ratio(const char *arg)
2757
{
2758
    int x = 0, y = 0;
2759
    double ar = 0;
2760
    const char *p;
2761
    char *end;
2762

    
2763
    p = strchr(arg, ':');
2764
    if (p) {
2765
        x = strtol(arg, &end, 10);
2766
        if (end == p)
2767
            y = strtol(end+1, &end, 10);
2768
        if (x > 0 && y > 0)
2769
            ar = (double)x / (double)y;
2770
    } else
2771
        ar = strtod(arg, NULL);
2772

    
2773
    if (!ar) {
2774
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2775
        ffmpeg_exit(1);
2776
    }
2777
    frame_aspect_ratio = ar;
2778
}
2779

    
2780
static int opt_metadata(const char *opt, const char *arg)
2781
{
2782
    char *mid= strchr(arg, '=');
2783

    
2784
    if(!mid){
2785
        fprintf(stderr, "Missing =\n");
2786
        ffmpeg_exit(1);
2787
    }
2788
    *mid++= 0;
2789

    
2790
    av_metadata_set2(&metadata, arg, mid, 0);
2791

    
2792
    return 0;
2793
}
2794

    
2795
static void opt_qscale(const char *arg)
2796
{
2797
    video_qscale = atof(arg);
2798
    if (video_qscale <= 0 ||
2799
        video_qscale > 255) {
2800
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2801
        ffmpeg_exit(1);
2802
    }
2803
}
2804

    
2805
static void opt_top_field_first(const char *arg)
2806
{
2807
    top_field_first= atoi(arg);
2808
}
2809

    
2810
static int opt_thread_count(const char *opt, const char *arg)
2811
{
2812
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2813
#if !HAVE_THREADS
2814
    if (verbose >= 0)
2815
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2816
#endif
2817
    return 0;
2818
}
2819

    
2820
static void opt_audio_sample_fmt(const char *arg)
2821
{
2822
    if (strcmp(arg, "list")) {
2823
        audio_sample_fmt = av_get_sample_fmt(arg);
2824
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2825
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2826
            ffmpeg_exit(1);
2827
        }
2828
    } else {
2829
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2830
        ffmpeg_exit(0);
2831
    }
2832
}
2833

    
2834
static int opt_audio_rate(const char *opt, const char *arg)
2835
{
2836
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2837
    return 0;
2838
}
2839

    
2840
static int opt_audio_channels(const char *opt, const char *arg)
2841
{
2842
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2843
    return 0;
2844
}
2845

    
2846
static void opt_video_channel(const char *arg)
2847
{
2848
    video_channel = strtol(arg, NULL, 0);
2849
}
2850

    
2851
static void opt_video_standard(const char *arg)
2852
{
2853
    video_standard = av_strdup(arg);
2854
}
2855

    
2856
static void opt_codec(int *pstream_copy, char **pcodec_name,
2857
                      int codec_type, const char *arg)
2858
{
2859
    av_freep(pcodec_name);
2860
    if (!strcmp(arg, "copy")) {
2861
        *pstream_copy = 1;
2862
    } else {
2863
        *pcodec_name = av_strdup(arg);
2864
    }
2865
}
2866

    
2867
static void opt_audio_codec(const char *arg)
2868
{
2869
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2870
}
2871

    
2872
static void opt_video_codec(const char *arg)
2873
{
2874
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2875
}
2876

    
2877
static void opt_subtitle_codec(const char *arg)
2878
{
2879
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2880
}
2881

    
2882
static int opt_codec_tag(const char *opt, const char *arg)
2883
{
2884
    char *tail;
2885
    uint32_t *codec_tag;
2886

    
2887
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2888
                !strcmp(opt, "vtag") ? &video_codec_tag :
2889
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2890
    if (!codec_tag)
2891
        return -1;
2892

    
2893
    *codec_tag = strtol(arg, &tail, 0);
2894
    if (!tail || *tail)
2895
        *codec_tag = AV_RL32(arg);
2896

    
2897
    return 0;
2898
}
2899

    
2900
static void opt_map(const char *arg)
2901
{
2902
    AVStreamMap *m;
2903
    char *p;
2904

    
2905
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2906
    m = &stream_maps[nb_stream_maps-1];
2907

    
2908
    m->file_index = strtol(arg, &p, 0);
2909
    if (*p)
2910
        p++;
2911

    
2912
    m->stream_index = strtol(p, &p, 0);
2913
    if (*p) {
2914
        p++;
2915
        m->sync_file_index = strtol(p, &p, 0);
2916
        if (*p)
2917
            p++;
2918
        m->sync_stream_index = strtol(p, &p, 0);
2919
    } else {
2920
        m->sync_file_index = m->file_index;
2921
        m->sync_stream_index = m->stream_index;
2922
    }
2923
}
2924

    
2925
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2926
{
2927
    *endptr = arg;
2928
    if (*arg == ',') {
2929
        *type = *(++arg);
2930
        switch (*arg) {
2931
        case 'g':
2932
            break;
2933
        case 's':
2934
        case 'c':
2935
        case 'p':
2936
            *index = strtol(++arg, endptr, 0);
2937
            break;
2938
        default:
2939
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2940
            ffmpeg_exit(1);
2941
        }
2942
    } else
2943
        *type = 'g';
2944
}
2945

    
2946
static void opt_map_metadata(const char *arg)
2947
{
2948
    AVMetaDataMap *m, *m1;
2949
    char *p;
2950

    
2951
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2952
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2953

    
2954
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
2955
    m->file = strtol(arg, &p, 0);
2956
    parse_meta_type(p, &m->type, &m->index, &p);
2957
    if (*p)
2958
        p++;
2959

    
2960
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2961
    m1->file = strtol(p, &p, 0);
2962
    parse_meta_type(p, &m1->type, &m1->index, &p);
2963

    
2964
    if (m->type == 'g' || m1->type == 'g')
2965
        metadata_global_autocopy = 0;
2966
    if (m->type == 's' || m1->type == 's')
2967
        metadata_streams_autocopy = 0;
2968
    if (m->type == 'c' || m1->type == 'c')
2969
        metadata_chapters_autocopy = 0;
2970
}
2971

    
2972
static void opt_map_meta_data(const char *arg)
2973
{
2974
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2975
                    "Use -map_metadata instead.\n");
2976
    opt_map_metadata(arg);
2977
}
2978

    
2979
static void opt_map_chapters(const char *arg)
2980
{
2981
    AVChapterMap *c;
2982
    char *p;
2983

    
2984
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
2985
                              nb_chapter_maps + 1);
2986
    c = &chapter_maps[nb_chapter_maps - 1];
2987
    c->out_file = strtol(arg, &p, 0);
2988
    if (*p)
2989
        p++;
2990

    
2991
    c->in_file = strtol(p, &p, 0);
2992
}
2993

    
2994
static void opt_input_ts_scale(const char *arg)
2995
{
2996
    unsigned int stream;
2997
    double scale;
2998
    char *p;
2999

    
3000
    stream = strtol(arg, &p, 0);
3001
    if (*p)
3002
        p++;
3003
    scale= strtod(p, &p);
3004

    
3005
    if(stream >= MAX_STREAMS)
3006
        ffmpeg_exit(1);
3007

    
3008
    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);
3009
    input_files_ts_scale[nb_input_files][stream]= scale;
3010
}
3011

    
3012
static int opt_recording_time(const char *opt, const char *arg)
3013
{
3014
    recording_time = parse_time_or_die(opt, arg, 1);
3015
    return 0;
3016
}
3017

    
3018
static int opt_start_time(const char *opt, const char *arg)
3019
{
3020
    start_time = parse_time_or_die(opt, arg, 1);
3021
    return 0;
3022
}
3023

    
3024
static int opt_recording_timestamp(const char *opt, const char *arg)
3025
{
3026
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3027
    return 0;
3028
}
3029

    
3030
static int opt_input_ts_offset(const char *opt, const char *arg)
3031
{
3032
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3033
    return 0;
3034
}
3035

    
3036
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3037
{
3038
    const char *codec_string = encoder ? "encoder" : "decoder";
3039
    AVCodec *codec;
3040

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

    
3070
static void opt_input_file(const char *filename)
3071
{
3072
    AVFormatContext *ic;
3073
    AVFormatParameters params, *ap = &params;
3074
    AVInputFormat *file_iformat = NULL;
3075
    int err, i, ret, rfps, rfps_base;
3076
    int64_t timestamp;
3077

    
3078
    if (last_asked_format) {
3079
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3080
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3081
            ffmpeg_exit(1);
3082
        }
3083
        last_asked_format = NULL;
3084
    }
3085

    
3086
    if (!strcmp(filename, "-"))
3087
        filename = "pipe:";
3088

    
3089
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3090
                    !strcmp(filename, "/dev/stdin");
3091

    
3092
    /* get default parameters from command line */
3093
    ic = avformat_alloc_context();
3094
    if (!ic) {
3095
        print_error(filename, AVERROR(ENOMEM));
3096
        ffmpeg_exit(1);
3097
    }
3098

    
3099
    memset(ap, 0, sizeof(*ap));
3100
    ap->prealloced_context = 1;
3101
    ap->sample_rate = audio_sample_rate;
3102
    ap->channels = audio_channels;
3103
    ap->time_base.den = frame_rate.num;
3104
    ap->time_base.num = frame_rate.den;
3105
    ap->width = frame_width;
3106
    ap->height = frame_height;
3107
    ap->pix_fmt = frame_pix_fmt;
3108
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3109
    ap->channel = video_channel;
3110
    ap->standard = video_standard;
3111

    
3112
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3113

    
3114
    ic->video_codec_id   =
3115
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3116
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3117
    ic->audio_codec_id   =
3118
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3119
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3120
    ic->subtitle_codec_id=
3121
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3122
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3123
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3124

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

    
3155
    ic->loop_input = loop_input;
3156

    
3157
    /* If not enough info to get the stream parameters, we decode the
3158
       first frames to get it. (used in mpeg case for example) */
3159
    ret = av_find_stream_info(ic);
3160
    if (ret < 0 && verbose >= 0) {
3161
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3162
        av_close_input_file(ic);
3163
        ffmpeg_exit(1);
3164
    }
3165

    
3166
    timestamp = start_time;
3167
    /* add the stream start time */
3168
    if (ic->start_time != AV_NOPTS_VALUE)
3169
        timestamp += ic->start_time;
3170

    
3171
    /* if seeking requested, we execute it */
3172
    if (start_time != 0) {
3173
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3174
        if (ret < 0) {
3175
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3176
                    filename, (double)timestamp / AV_TIME_BASE);
3177
        }
3178
        /* reset seek info */
3179
        start_time = 0;
3180
    }
3181

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

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

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

    
3234
                    (float)rfps / rfps_base, rfps, rfps_base);
3235
            }
3236
            /* update the current frame rate to match the stream frame rate */
3237
            frame_rate.num = rfps;
3238
            frame_rate.den = rfps_base;
3239

    
3240
            if(video_disable)
3241
                st->discard= AVDISCARD_ALL;
3242
            else if(video_discard)
3243
                st->discard= video_discard;
3244
            break;
3245
        case AVMEDIA_TYPE_DATA:
3246
            break;
3247
        case AVMEDIA_TYPE_SUBTITLE:
3248
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3249
            if(subtitle_disable)
3250
                st->discard = AVDISCARD_ALL;
3251
            break;
3252
        case AVMEDIA_TYPE_ATTACHMENT:
3253
        case AVMEDIA_TYPE_UNKNOWN:
3254
            break;
3255
        default:
3256
            abort();
3257
        }
3258
    }
3259

    
3260
    input_files[nb_input_files] = ic;
3261
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3262
    /* dump the file content */
3263
    if (verbose >= 0)
3264
        av_dump_format(ic, nb_input_files, filename, 0);
3265

    
3266
    nb_input_files++;
3267

    
3268
    video_channel = 0;
3269

    
3270
    av_freep(&video_codec_name);
3271
    av_freep(&audio_codec_name);
3272
    av_freep(&subtitle_codec_name);
3273
}
3274

    
3275
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3276
                                         int *has_subtitle_ptr)
3277
{
3278
    int has_video, has_audio, has_subtitle, i, j;
3279
    AVFormatContext *ic;
3280

    
3281
    has_video = 0;
3282
    has_audio = 0;
3283
    has_subtitle = 0;
3284
    for(j=0;j<nb_input_files;j++) {
3285
        ic = input_files[j];
3286
        for(i=0;i<ic->nb_streams;i++) {
3287
            AVCodecContext *enc = ic->streams[i]->codec;
3288
            switch(enc->codec_type) {
3289
            case AVMEDIA_TYPE_AUDIO:
3290
                has_audio = 1;
3291
                break;
3292
            case AVMEDIA_TYPE_VIDEO:
3293
                has_video = 1;
3294
                break;
3295
            case AVMEDIA_TYPE_SUBTITLE:
3296
                has_subtitle = 1;
3297
                break;
3298
            case AVMEDIA_TYPE_DATA:
3299
            case AVMEDIA_TYPE_ATTACHMENT:
3300
            case AVMEDIA_TYPE_UNKNOWN:
3301
                break;
3302
            default:
3303
                abort();
3304
            }
3305
        }
3306
    }
3307
    *has_video_ptr = has_video;
3308
    *has_audio_ptr = has_audio;
3309
    *has_subtitle_ptr = has_subtitle;
3310
}
3311

    
3312
static void new_video_stream(AVFormatContext *oc, int file_idx)
3313
{
3314
    AVStream *st;
3315
    AVOutputStream *ost;
3316
    AVCodecContext *video_enc;
3317
    enum CodecID codec_id = CODEC_ID_NONE;
3318
    AVCodec *codec= NULL;
3319

    
3320
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3321
    if (!st) {
3322
        fprintf(stderr, "Could not alloc stream\n");
3323
        ffmpeg_exit(1);
3324
    }
3325
    ost = new_output_stream(oc, file_idx);
3326

    
3327
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3328
    if(!video_stream_copy){
3329
        if (video_codec_name) {
3330
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3331
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3332
            codec = avcodec_find_encoder_by_name(video_codec_name);
3333
            output_codecs[nb_output_codecs-1] = codec;
3334
        } else {
3335
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3336
            codec = avcodec_find_encoder(codec_id);
3337
        }
3338
    }
3339

    
3340
    avcodec_get_context_defaults3(st->codec, codec);
3341
    ost->bitstream_filters = video_bitstream_filters;
3342
    video_bitstream_filters= NULL;
3343

    
3344
    st->codec->thread_count= thread_count;
3345

    
3346
    video_enc = st->codec;
3347

    
3348
    if(video_codec_tag)
3349
        video_enc->codec_tag= video_codec_tag;
3350

    
3351
    if(   (video_global_header&1)
3352
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3353
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3354
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3355
    }
3356
    if(video_global_header&2){
3357
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3358
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3359
    }
3360

    
3361
    if (video_stream_copy) {
3362
        st->stream_copy = 1;
3363
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3364
        video_enc->sample_aspect_ratio =
3365
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3366
    } else {
3367
        const char *p;
3368
        int i;
3369
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3370

    
3371
        video_enc->codec_id = codec_id;
3372
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3373

    
3374
        if (codec && codec->supported_framerates && !force_fps)
3375
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3376
        video_enc->time_base.den = fps.num;
3377
        video_enc->time_base.num = fps.den;
3378

    
3379
        video_enc->width = frame_width;
3380
        video_enc->height = frame_height;
3381
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3382
        video_enc->pix_fmt = frame_pix_fmt;
3383
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3384

    
3385
        choose_pixel_fmt(st, codec);
3386

    
3387
        if (intra_only)
3388
            video_enc->gop_size = 0;
3389
        if (video_qscale || same_quality) {
3390
            video_enc->flags |= CODEC_FLAG_QSCALE;
3391
            video_enc->global_quality=
3392
                st->quality = FF_QP2LAMBDA * video_qscale;
3393
        }
3394

    
3395
        if(intra_matrix)
3396
            video_enc->intra_matrix = intra_matrix;
3397
        if(inter_matrix)
3398
            video_enc->inter_matrix = inter_matrix;
3399

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

    
3430
        if (do_psnr)
3431
            video_enc->flags|= CODEC_FLAG_PSNR;
3432

    
3433
        /* two pass mode */
3434
        if (do_pass) {
3435
            if (do_pass == 1) {
3436
                video_enc->flags |= CODEC_FLAG_PASS1;
3437
            } else {
3438
                video_enc->flags |= CODEC_FLAG_PASS2;
3439
            }
3440
        }
3441

    
3442
        if (forced_key_frames)
3443
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3444
    }
3445
    if (video_language) {
3446
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3447
        av_freep(&video_language);
3448
    }
3449

    
3450
    /* reset some key parameters */
3451
    video_disable = 0;
3452
    av_freep(&video_codec_name);
3453
    av_freep(&forced_key_frames);
3454
    video_stream_copy = 0;
3455
    frame_pix_fmt = PIX_FMT_NONE;
3456
}
3457

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

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

    
3473
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3474
    if(!audio_stream_copy){
3475
        if (audio_codec_name) {
3476
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3477
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3478
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3479
            output_codecs[nb_output_codecs-1] = codec;
3480
        } else {
3481
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3482
            codec = avcodec_find_encoder(codec_id);
3483
        }
3484
    }
3485

    
3486
    avcodec_get_context_defaults3(st->codec, codec);
3487

    
3488
    ost->bitstream_filters = audio_bitstream_filters;
3489
    audio_bitstream_filters= NULL;
3490

    
3491
    st->codec->thread_count= thread_count;
3492

    
3493
    audio_enc = st->codec;
3494
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3495

    
3496
    if(audio_codec_tag)
3497
        audio_enc->codec_tag= audio_codec_tag;
3498

    
3499
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3500
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3501
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3502
    }
3503
    if (audio_stream_copy) {
3504
        st->stream_copy = 1;
3505
        audio_enc->channels = audio_channels;
3506
        audio_enc->sample_rate = audio_sample_rate;
3507
    } else {
3508
        audio_enc->codec_id = codec_id;
3509
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3510

    
3511
        if (audio_qscale > QSCALE_NONE) {
3512
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3513
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3514
        }
3515
        audio_enc->channels = audio_channels;
3516
        audio_enc->sample_fmt = audio_sample_fmt;
3517
        audio_enc->sample_rate = audio_sample_rate;
3518
        audio_enc->channel_layout = channel_layout;
3519
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3520
            audio_enc->channel_layout = 0;
3521
        choose_sample_fmt(st, codec);
3522
        choose_sample_rate(st, codec);
3523
    }
3524
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3525
    if (audio_language) {
3526
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3527
        av_freep(&audio_language);
3528
    }
3529

    
3530
    /* reset some key parameters */
3531
    audio_disable = 0;
3532
    av_freep(&audio_codec_name);
3533
    audio_stream_copy = 0;
3534
}
3535

    
3536
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3537
{
3538
    AVStream *st;
3539
    AVOutputStream *ost;
3540
    AVCodec *codec=NULL;
3541
    AVCodecContext *subtitle_enc;
3542
    enum CodecID codec_id = CODEC_ID_NONE;
3543

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

    
3564
    ost->bitstream_filters = subtitle_bitstream_filters;
3565
    subtitle_bitstream_filters= NULL;
3566

    
3567
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3568

    
3569
    if(subtitle_codec_tag)
3570
        subtitle_enc->codec_tag= subtitle_codec_tag;
3571

    
3572
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3573
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3574
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3575
    }
3576
    if (subtitle_stream_copy) {
3577
        st->stream_copy = 1;
3578
    } else {
3579
        subtitle_enc->codec_id = codec_id;
3580
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3581
    }
3582

    
3583
    if (subtitle_language) {
3584
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3585
        av_freep(&subtitle_language);
3586
    }
3587

    
3588
    subtitle_disable = 0;
3589
    av_freep(&subtitle_codec_name);
3590
    subtitle_stream_copy = 0;
3591
}
3592

    
3593
static int opt_new_stream(const char *opt, const char *arg)
3594
{
3595
    AVFormatContext *oc;
3596
    int file_idx = nb_output_files - 1;
3597
    if (nb_output_files <= 0) {
3598
        fprintf(stderr, "At least one output file must be specified\n");
3599
        ffmpeg_exit(1);
3600
    }
3601
    oc = output_files[file_idx];
3602

    
3603
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3604
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3605
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3606
    else av_assert0(0);
3607
    return 0;
3608
}
3609

    
3610
/* arg format is "output-stream-index:streamid-value". */
3611
static int opt_streamid(const char *opt, const char *arg)
3612
{
3613
    int idx;
3614
    char *p;
3615
    char idx_str[16];
3616

    
3617
    strncpy(idx_str, arg, sizeof(idx_str));
3618
    idx_str[sizeof(idx_str)-1] = '\0';
3619
    p = strchr(idx_str, ':');
3620
    if (!p) {
3621
        fprintf(stderr,
3622
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3623
                arg, opt);
3624
        ffmpeg_exit(1);
3625
    }
3626
    *p++ = '\0';
3627
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3628
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3629
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3630
    return 0;
3631
}
3632

    
3633
static void opt_output_file(const char *filename)
3634
{
3635
    AVFormatContext *oc;
3636
    int err, use_video, use_audio, use_subtitle;
3637
    int input_has_video, input_has_audio, input_has_subtitle;
3638
    AVFormatParameters params, *ap = &params;
3639
    AVOutputFormat *file_oformat;
3640

    
3641
    if (!strcmp(filename, "-"))
3642
        filename = "pipe:";
3643

    
3644
    oc = avformat_alloc_context();
3645
    if (!oc) {
3646
        print_error(filename, AVERROR(ENOMEM));
3647
        ffmpeg_exit(1);
3648
    }
3649

    
3650
    if (last_asked_format) {
3651
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3652
        if (!file_oformat) {
3653
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3654
            ffmpeg_exit(1);
3655
        }
3656
        last_asked_format = NULL;
3657
    } else {
3658
        file_oformat = av_guess_format(NULL, filename, NULL);
3659
        if (!file_oformat) {
3660
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3661
                    filename);
3662
            ffmpeg_exit(1);
3663
        }
3664
    }
3665

    
3666
    oc->oformat = file_oformat;
3667
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3668

    
3669
    if (!strcmp(file_oformat->name, "ffm") &&
3670
        av_strstart(filename, "http:", NULL)) {
3671
        /* special case for files sent to ffserver: we get the stream
3672
           parameters from ffserver */
3673
        int err = read_ffserver_streams(oc, filename);
3674
        if (err < 0) {
3675
            print_error(filename, err);
3676
            ffmpeg_exit(1);
3677
        }
3678
    } else {
3679
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3680
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3681
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3682

    
3683
        /* disable if no corresponding type found and at least one
3684
           input file */
3685
        if (nb_input_files > 0) {
3686
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3687
                                         &input_has_subtitle);
3688
            if (!input_has_video)
3689
                use_video = 0;
3690
            if (!input_has_audio)
3691
                use_audio = 0;
3692
            if (!input_has_subtitle)
3693
                use_subtitle = 0;
3694
        }
3695

    
3696
        /* manual disable */
3697
        if (audio_disable)    use_audio    = 0;
3698
        if (video_disable)    use_video    = 0;
3699
        if (subtitle_disable) use_subtitle = 0;
3700

    
3701
        if (use_video)    new_video_stream(oc, nb_output_files);
3702
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3703
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3704

    
3705
        oc->timestamp = recording_timestamp;
3706

    
3707
        av_metadata_copy(&oc->metadata, metadata, 0);
3708
        av_metadata_free(&metadata);
3709
    }
3710

    
3711
    output_files[nb_output_files++] = oc;
3712

    
3713
    /* check filename in case of an image number is expected */
3714
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3715
        if (!av_filename_number_test(oc->filename)) {
3716
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3717
            ffmpeg_exit(1);
3718
        }
3719
    }
3720

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

    
3743
        /* open the file */
3744
        if ((err = avio_open(&oc->pb, filename, URL_WRONLY)) < 0) {
3745
            print_error(filename, err);
3746
            ffmpeg_exit(1);
3747
        }
3748
    }
3749

    
3750
    memset(ap, 0, sizeof(*ap));
3751
    if (av_set_parameters(oc, ap) < 0) {
3752
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3753
                oc->filename);
3754
        ffmpeg_exit(1);
3755
    }
3756

    
3757
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3758
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3759
    oc->loop_output = loop_output;
3760
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3761

    
3762
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3763

    
3764
    av_freep(&forced_key_frames);
3765
}
3766

    
3767
/* same option as mencoder */
3768
static void opt_pass(const char *pass_str)
3769
{
3770
    int pass;
3771
    pass = atoi(pass_str);
3772
    if (pass != 1 && pass != 2) {
3773
        fprintf(stderr, "pass number can be only 1 or 2\n");
3774
        ffmpeg_exit(1);
3775
    }
3776
    do_pass = pass;
3777
}
3778

    
3779
static int64_t getutime(void)
3780
{
3781
#if HAVE_GETRUSAGE
3782
    struct rusage rusage;
3783

    
3784
    getrusage(RUSAGE_SELF, &rusage);
3785
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3786
#elif HAVE_GETPROCESSTIMES
3787
    HANDLE proc;
3788
    FILETIME c, e, k, u;
3789
    proc = GetCurrentProcess();
3790
    GetProcessTimes(proc, &c, &e, &k, &u);
3791
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3792
#else
3793
    return av_gettime();
3794
#endif
3795
}
3796

    
3797
static int64_t getmaxrss(void)
3798
{
3799
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3800
    struct rusage rusage;
3801
    getrusage(RUSAGE_SELF, &rusage);
3802
    return (int64_t)rusage.ru_maxrss * 1024;
3803
#elif HAVE_GETPROCESSMEMORYINFO
3804
    HANDLE proc;
3805
    PROCESS_MEMORY_COUNTERS memcounters;
3806
    proc = GetCurrentProcess();
3807
    memcounters.cb = sizeof(memcounters);
3808
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3809
    return memcounters.PeakPagefileUsage;
3810
#else
3811
    return 0;
3812
#endif
3813
}
3814

    
3815
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3816
{
3817
    int i;
3818
    const char *p = str;
3819
    for(i = 0;; i++) {
3820
        dest[i] = atoi(p);
3821
        if(i == 63)
3822
            break;
3823
        p = strchr(p, ',');
3824
        if(!p) {
3825
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3826
            ffmpeg_exit(1);
3827
        }
3828
        p++;
3829
    }
3830
}
3831

    
3832
static void opt_inter_matrix(const char *arg)
3833
{
3834
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3835
    parse_matrix_coeffs(inter_matrix, arg);
3836
}
3837

    
3838
static void opt_intra_matrix(const char *arg)
3839
{
3840
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3841
    parse_matrix_coeffs(intra_matrix, arg);
3842
}
3843

    
3844
static void show_usage(void)
3845
{
3846
    printf("Hyper fast Audio and Video encoder\n");
3847
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3848
    printf("\n");
3849
}
3850

    
3851
static void show_help(void)
3852
{
3853
    AVCodec *c;
3854
    AVOutputFormat *oformat = NULL;
3855

    
3856
    av_log_set_callback(log_callback_help);
3857
    show_usage();
3858
    show_help_options(options, "Main options:\n",
3859
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3860
    show_help_options(options, "\nAdvanced options:\n",
3861
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3862
                      OPT_EXPERT);
3863
    show_help_options(options, "\nVideo options:\n",
3864
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3865
                      OPT_VIDEO);
3866
    show_help_options(options, "\nAdvanced Video options:\n",
3867
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3868
                      OPT_VIDEO | OPT_EXPERT);
3869
    show_help_options(options, "\nAudio options:\n",
3870
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3871
                      OPT_AUDIO);
3872
    show_help_options(options, "\nAdvanced Audio options:\n",
3873
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3874
                      OPT_AUDIO | OPT_EXPERT);
3875
    show_help_options(options, "\nSubtitle options:\n",
3876
                      OPT_SUBTITLE | OPT_GRAB,
3877
                      OPT_SUBTITLE);
3878
    show_help_options(options, "\nAudio/Video grab options:\n",
3879
                      OPT_GRAB,
3880
                      OPT_GRAB);
3881
    printf("\n");
3882
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3883
    printf("\n");
3884

    
3885
    /* individual codec options */
3886
    c = NULL;
3887
    while ((c = av_codec_next(c))) {
3888
        if (c->priv_class) {
3889
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3890
            printf("\n");
3891
        }
3892
    }
3893

    
3894
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3895
    printf("\n");
3896

    
3897
    /* individual muxer options */
3898
    while ((oformat = av_oformat_next(oformat))) {
3899
        if (oformat->priv_class) {
3900
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3901
            printf("\n");
3902
        }
3903
    }
3904

    
3905
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3906
}
3907

    
3908
static void opt_target(const char *arg)
3909
{
3910
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3911
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3912

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

    
3957
    if(norm == UNKNOWN) {
3958
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3959
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3960
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3961
        ffmpeg_exit(1);
3962
    }
3963

    
3964
    if(!strcmp(arg, "vcd")) {
3965

    
3966
        opt_video_codec("mpeg1video");
3967
        opt_audio_codec("mp2");
3968
        opt_format("vcd");
3969

    
3970
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3971
        opt_frame_rate(NULL, frame_rates[norm]);
3972
        opt_default("g", norm == PAL ? "15" : "18");
3973

    
3974
        opt_default("b", "1150000");
3975
        opt_default("maxrate", "1150000");
3976
        opt_default("minrate", "1150000");
3977
        opt_default("bufsize", "327680"); // 40*1024*8;
3978

    
3979
        opt_default("ab", "224000");
3980
        audio_sample_rate = 44100;
3981
        audio_channels = 2;
3982

    
3983
        opt_default("packetsize", "2324");
3984
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3985

    
3986
        /* We have to offset the PTS, so that it is consistent with the SCR.
3987
           SCR starts at 36000, but the first two packs contain only padding
3988
           and the first pack from the other stream, respectively, may also have
3989
           been written before.
3990
           So the real data starts at SCR 36000+3*1200. */
3991
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3992
    } else if(!strcmp(arg, "svcd")) {
3993

    
3994
        opt_video_codec("mpeg2video");
3995
        opt_audio_codec("mp2");
3996
        opt_format("svcd");
3997

    
3998
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3999
        opt_frame_rate(NULL, frame_rates[norm]);
4000
        opt_default("g", norm == PAL ? "15" : "18");
4001

    
4002
        opt_default("b", "2040000");
4003
        opt_default("maxrate", "2516000");
4004
        opt_default("minrate", "0"); //1145000;
4005
        opt_default("bufsize", "1835008"); //224*1024*8;
4006
        opt_default("flags", "+scan_offset");
4007

    
4008

    
4009
        opt_default("ab", "224000");
4010
        audio_sample_rate = 44100;
4011

    
4012
        opt_default("packetsize", "2324");
4013

    
4014
    } else if(!strcmp(arg, "dvd")) {
4015

    
4016
        opt_video_codec("mpeg2video");
4017
        opt_audio_codec("ac3");
4018
        opt_format("dvd");
4019

    
4020
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4021
        opt_frame_rate(NULL, frame_rates[norm]);
4022
        opt_default("g", norm == PAL ? "15" : "18");
4023

    
4024
        opt_default("b", "6000000");
4025
        opt_default("maxrate", "9000000");
4026
        opt_default("minrate", "0"); //1500000;
4027
        opt_default("bufsize", "1835008"); //224*1024*8;
4028

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

    
4032
        opt_default("ab", "448000");
4033
        audio_sample_rate = 48000;
4034

    
4035
    } else if(!strncmp(arg, "dv", 2)) {
4036

    
4037
        opt_format("dv");
4038

    
4039
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4040
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4041
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4042
        opt_frame_rate(NULL, frame_rates[norm]);
4043

    
4044
        audio_sample_rate = 48000;
4045
        audio_channels = 2;
4046

    
4047
    } else {
4048
        fprintf(stderr, "Unknown target: %s\n", arg);
4049
        ffmpeg_exit(1);
4050
    }
4051
}
4052

    
4053
static void opt_vstats_file (const char *arg)
4054
{
4055
    av_free (vstats_filename);
4056
    vstats_filename=av_strdup (arg);
4057
}
4058

    
4059
static void opt_vstats (void)
4060
{
4061
    char filename[40];
4062
    time_t today2 = time(NULL);
4063
    struct tm *today = localtime(&today2);
4064

    
4065
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4066
             today->tm_sec);
4067
    opt_vstats_file(filename);
4068
}
4069

    
4070
static int opt_bsf(const char *opt, const char *arg)
4071
{
4072
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4073
    AVBitStreamFilterContext **bsfp;
4074

    
4075
    if(!bsfc){
4076
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4077
        ffmpeg_exit(1);
4078
    }
4079

    
4080
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4081
          *opt == 'a' ? &audio_bitstream_filters :
4082
                        &subtitle_bitstream_filters;
4083
    while(*bsfp)
4084
        bsfp= &(*bsfp)->next;
4085

    
4086
    *bsfp= bsfc;
4087

    
4088
    return 0;
4089
}
4090

    
4091
static int opt_preset(const char *opt, const char *arg)
4092
{
4093
    FILE *f=NULL;
4094
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4095
    char *codec_name = *opt == 'v' ? video_codec_name :
4096
                       *opt == 'a' ? audio_codec_name :
4097
                                     subtitle_codec_name;
4098

    
4099
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4100
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4101
        ffmpeg_exit(1);
4102
    }
4103

    
4104
    while(!feof(f)){
4105
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4106
        if(line[0] == '#' && !e)
4107
            continue;
4108
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4109
        if(e){
4110
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4111
            ffmpeg_exit(1);
4112
        }
4113
        if(!strcmp(tmp, "acodec")){
4114
            opt_audio_codec(tmp2);
4115
        }else if(!strcmp(tmp, "vcodec")){
4116
            opt_video_codec(tmp2);
4117
        }else if(!strcmp(tmp, "scodec")){
4118
            opt_subtitle_codec(tmp2);
4119
        }else if(opt_default(tmp, tmp2) < 0){
4120
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4121
            ffmpeg_exit(1);
4122
        }
4123
    }
4124

    
4125
    fclose(f);
4126

    
4127
    return 0;
4128
}
4129

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

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

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

    
4237
    /* subtitle options */
4238
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4239
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4240
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4241
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4242
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4243

    
4244
    /* grab options */
4245
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4246
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4247
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4248

    
4249
    /* muxer options */
4250
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4251
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4252

    
4253
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4254
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4255
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4256

    
4257
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4258
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4259
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4260
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4261

    
4262
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4263
    { NULL, },
4264
};
4265

    
4266
int main(int argc, char **argv)
4267
{
4268
    int64_t ti;
4269

    
4270
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4271

    
4272
    avcodec_register_all();
4273
#if CONFIG_AVDEVICE
4274
    avdevice_register_all();
4275
#endif
4276
#if CONFIG_AVFILTER
4277
    avfilter_register_all();
4278
#endif
4279
    av_register_all();
4280

    
4281
#if HAVE_ISATTY
4282
    if(isatty(STDIN_FILENO))
4283
        url_set_interrupt_cb(decode_interrupt_cb);
4284
#endif
4285

    
4286
    init_opts();
4287

    
4288
    show_banner();
4289

    
4290
    /* parse options */
4291
    parse_options(argc, argv, options, opt_output_file);
4292

    
4293
    if(nb_output_files <= 0 && nb_input_files == 0) {
4294
        show_usage();
4295
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4296
        ffmpeg_exit(1);
4297
    }
4298

    
4299
    /* file converter / grab */
4300
    if (nb_output_files <= 0) {
4301
        fprintf(stderr, "At least one output file must be specified\n");
4302
        ffmpeg_exit(1);
4303
    }
4304

    
4305
    if (nb_input_files == 0) {
4306
        fprintf(stderr, "At least one input file must be specified\n");
4307
        ffmpeg_exit(1);
4308
    }
4309

    
4310
    ti = getutime();
4311
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4312
                  stream_maps, nb_stream_maps) < 0)
4313
        ffmpeg_exit(1);
4314
    ti = getutime() - ti;
4315
    if (do_benchmark) {
4316
        int maxrss = getmaxrss() / 1024;
4317
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4318
    }
4319

    
4320
    return ffmpeg_exit(0);
4321
}