Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 8fb566fd

History | View | Annotate | Download (161 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
#include "config.h"
23
#include <ctype.h>
24
#include <string.h>
25
#include <math.h>
26
#include <stdlib.h>
27
#include <errno.h>
28
#include <signal.h>
29
#include <limits.h>
30
#include <unistd.h>
31
#include "libavformat/avformat.h"
32
#include "libavdevice/avdevice.h"
33
#include "libswscale/swscale.h"
34
#include "libavutil/opt.h"
35
#include "libavcodec/audioconvert.h"
36
#include "libavutil/audioconvert.h"
37
#include "libavutil/parseutils.h"
38
#include "libavutil/samplefmt.h"
39
#include "libavutil/colorspace.h"
40
#include "libavutil/fifo.h"
41
#include "libavutil/intreadwrite.h"
42
#include "libavutil/pixdesc.h"
43
#include "libavutil/avstring.h"
44
#include "libavutil/libm.h"
45
#include "libavformat/os_support.h"
46

    
47
#if CONFIG_AVFILTER
48
# include "libavfilter/avfilter.h"
49
# include "libavfilter/avfiltergraph.h"
50
# include "libavfilter/vsrc_buffer.h"
51
#endif
52

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

    
65
#if HAVE_SYS_SELECT_H
66
#include <sys/select.h>
67
#endif
68

    
69
#include <time.h>
70

    
71
#include "cmdutils.h"
72

    
73
#include "libavutil/avassert.h"
74

    
75
const char program_name[] = "ffmpeg";
76
const int program_birth_year = 2000;
77

    
78
/* select an input stream for an output stream */
79
typedef struct AVStreamMap {
80
    int file_index;
81
    int stream_index;
82
    int sync_file_index;
83
    int sync_stream_index;
84
} AVStreamMap;
85

    
86
/**
87
 * select an input file for an output file
88
 */
89
typedef struct AVMetaDataMap {
90
    int  file;      //< file index
91
    char type;      //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
92
    int  index;     //< stream/chapter/program number
93
} AVMetaDataMap;
94

    
95
typedef struct AVChapterMap {
96
    int in_file;
97
    int out_file;
98
} AVChapterMap;
99

    
100
static const OptionDef options[];
101

    
102
#define MAX_FILES 100
103
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
104

    
105
#define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h
106

    
107
static const char *last_asked_format = NULL;
108
static AVFormatContext *input_files[MAX_FILES];
109
static int64_t input_files_ts_offset[MAX_FILES];
110
static double *input_files_ts_scale[MAX_FILES] = {NULL};
111
static AVCodec **input_codecs = NULL;
112
static int nb_input_files = 0;
113
static int nb_input_codecs = 0;
114
static int nb_input_files_ts_scale[MAX_FILES] = {0};
115

    
116
static AVFormatContext *output_files[MAX_FILES];
117
static AVCodec **output_codecs = NULL;
118
static int nb_output_files = 0;
119
static int nb_output_codecs = 0;
120

    
121
static AVStreamMap *stream_maps = NULL;
122
static int nb_stream_maps;
123

    
124
/* first item specifies output metadata, second is input */
125
static AVMetaDataMap (*meta_data_maps)[2] = NULL;
126
static int nb_meta_data_maps;
127
static int metadata_global_autocopy   = 1;
128
static int metadata_streams_autocopy  = 1;
129
static int metadata_chapters_autocopy = 1;
130

    
131
static AVChapterMap *chapter_maps = NULL;
132
static int nb_chapter_maps;
133

    
134
/* indexed by output file stream index */
135
static int *streamid_map = NULL;
136
static int nb_streamid_map = 0;
137

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

    
167
static int intra_only = 0;
168
static int audio_sample_rate = 44100;
169
static int64_t channel_layout = 0;
170
#define QSCALE_NONE -99999
171
static float audio_qscale = QSCALE_NONE;
172
static int audio_disable = 0;
173
static int audio_channels = 1;
174
static char  *audio_codec_name = NULL;
175
static unsigned int audio_codec_tag = 0;
176
static char *audio_language = NULL;
177

    
178
static int subtitle_disable = 0;
179
static char *subtitle_codec_name = NULL;
180
static char *subtitle_language = NULL;
181
static unsigned int subtitle_codec_tag = 0;
182

    
183
static int data_disable = 0;
184
static char *data_codec_name = NULL;
185
static unsigned int data_codec_tag = 0;
186

    
187
static float mux_preload= 0.5;
188
static float mux_max_delay= 0.7;
189

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

    
218
static int rate_emu = 0;
219

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

    
223
static int audio_volume = 256;
224

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

    
239
static float dts_delta_threshold = 10;
240

    
241
static int64_t timer_start;
242

    
243
static uint8_t *audio_buf;
244
static uint8_t *audio_out;
245
static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
246

    
247
static short *samples;
248

    
249
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
250
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
251
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
252

    
253
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
254

    
255
struct AVInputStream;
256

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

    
278
    /* forced key frames */
279
    int64_t *forced_kf_pts;
280
    int forced_kf_count;
281
    int forced_kf_index;
282

    
283
    /* audio only */
284
    int audio_resample;
285
    ReSampleContext *resample; /* for audio resampling */
286
    int resample_sample_fmt;
287
    int resample_channels;
288
    int resample_sample_rate;
289
    int reformat_pair;
290
    AVAudioConvert *reformat_ctx;
291
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
292
    FILE *logfile;
293

    
294
   int sws_flags;
295
} AVOutputStream;
296

    
297
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
298
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
299

    
300
typedef struct AVInputStream {
301
    int file_index;
302
    int index;
303
    AVStream *st;
304
    int discard;             /* true if stream data should be discarded */
305
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
306
    int64_t sample_index;      /* current sample */
307

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

    
325
typedef struct AVInputFile {
326
    int eof_reached;      /* true if eof reached */
327
    int ist_index;        /* index of first stream in ist_table */
328
    int buffer_size;      /* current total buffer size */
329
    int nb_streams;       /* nb streams we are aware of */
330
} AVInputFile;
331

    
332
#if CONFIG_AVFILTER
333

    
334
static int configure_video_filters(AVInputStream *ist, AVOutputStream *ost)
335
{
336
    AVFilterContext *last_filter, *filter;
337
    /** filter graph containing all filters including input & output */
338
    AVCodecContext *codec = ost->st->codec;
339
    AVCodecContext *icodec = ist->st->codec;
340
    FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
341
    AVRational sample_aspect_ratio;
342
    char args[255];
343
    int ret;
344

    
345
    graph = avfilter_graph_alloc();
346

    
347
    if (ist->st->sample_aspect_ratio.num){
348
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
349
    }else
350
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
351

    
352
    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
353
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
354
             sample_aspect_ratio.num, sample_aspect_ratio.den);
355

    
356
    ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
357
                                       "src", args, NULL, graph);
358
    if (ret < 0)
359
        return ret;
360
    ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
361
                                       "out", NULL, &ffsink_ctx, graph);
362
    if (ret < 0)
363
        return ret;
364
    last_filter = ist->input_video_filter;
365

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

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

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

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

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

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

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

    
407
    codec->width  = ist->output_video_filter->inputs[0]->w;
408
    codec->height = ist->output_video_filter->inputs[0]->h;
409
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
410
        ist->output_video_filter->inputs[0]->sample_aspect_ratio;
411

    
412
    return 0;
413
}
414
#endif /* CONFIG_AVFILTER */
415

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

    
421
static volatile int received_sigterm = 0;
422

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

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

    
439
static int decode_interrupt_cb(void)
440
{
441
    return received_sigterm;
442
}
443

    
444
static int ffmpeg_exit(int ret)
445
{
446
    int i;
447

    
448
    /* close files */
449
    for(i=0;i<nb_output_files;i++) {
450
        AVFormatContext *s = output_files[i];
451
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
452
            avio_close(s->pb);
453
        avformat_free_context(s);
454
        av_free(output_streams_for_file[i]);
455
    }
456
    for(i=0;i<nb_input_files;i++) {
457
        av_close_input_file(input_files[i]);
458
        av_free(input_files_ts_scale[i]);
459
    }
460

    
461
    av_free(intra_matrix);
462
    av_free(inter_matrix);
463

    
464
    if (vstats_file)
465
        fclose(vstats_file);
466
    av_free(vstats_filename);
467

    
468
    av_free(streamid_map);
469
    av_free(input_codecs);
470
    av_free(output_codecs);
471
    av_free(stream_maps);
472
    av_free(meta_data_maps);
473

    
474
    av_free(video_codec_name);
475
    av_free(audio_codec_name);
476
    av_free(subtitle_codec_name);
477
    av_free(data_codec_name);
478

    
479
    av_free(video_standard);
480

    
481
    uninit_opts();
482
    av_free(audio_buf);
483
    av_free(audio_out);
484
    allocated_audio_buf_size= allocated_audio_out_size= 0;
485
    av_free(samples);
486

    
487
#if CONFIG_AVFILTER
488
    avfilter_uninit();
489
#endif
490

    
491
    if (received_sigterm) {
492
        fprintf(stderr,
493
            "Received signal %d: terminating.\n",
494
            (int) received_sigterm);
495
        exit (255);
496
    }
497

    
498
    exit(ret); /* not all OS-es handle main() return value */
499
    return ret;
500
}
501

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

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

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

    
561
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
562
{
563
    if(codec && codec->pix_fmts){
564
        const enum PixelFormat *p= codec->pix_fmts;
565
        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
566
            if(st->codec->codec_id==CODEC_ID_MJPEG){
567
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
568
            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
569
                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};
570
            }
571
        }
572
        for(; *p!=-1; p++){
573
            if(*p == st->codec->pix_fmt)
574
                break;
575
        }
576
        if (*p == -1) {
577
            if(st->codec->pix_fmt != PIX_FMT_NONE)
578
                av_log(NULL, AV_LOG_WARNING,
579
                        "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
580
                        av_pix_fmt_descriptors[st->codec->pix_fmt].name,
581
                        codec->name,
582
                        av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
583
            st->codec->pix_fmt = codec->pix_fmts[0];
584
        }
585
    }
586
}
587

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

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

    
607
    ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
608
    return ost;
609
}
610

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

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

    
626
        s->nb_streams++;
627

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

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

    
652
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
653
            nopts = 1;
654

    
655
        new_output_stream(s, nb_output_files);
656
    }
657

    
658
    if (!nopts)
659
        s->timestamp = av_gettime();
660

    
661
    av_close_input_file(ic);
662
    return 0;
663
}
664

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

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

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

    
694
        bsfc= bsfc->next;
695
    }
696

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

    
704
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
705

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

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

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

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

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

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

    
746
    if (enc->channels != dec->channels)
747
        ost->audio_resample = 1;
748

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

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

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

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

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

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

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

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

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

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

    
888
        frame_bytes = enc->frame_size * osize * enc->channels;
889

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

    
894
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
895

    
896
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
897

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

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

    
919
        ost->sync_opts += size_out / (osize * enc->channels);
920

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

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

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

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

    
957
    dec = ist->st->codec;
958

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

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

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

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

    
984
    if (picture != picture2)
985
        *picture = *picture2;
986
    *bufp = buf;
987
}
988

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

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

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

    
1011
    enc = ost->st->codec;
1012

    
1013
    if (!subtitle_out) {
1014
        subtitle_out = av_malloc(subtitle_out_max_size);
1015
    }
1016

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

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

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

    
1055
static int bit_buffer_size= 1024*256;
1056
static uint8_t *bit_buffer= NULL;
1057

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

    
1069
    enc = ost->st->codec;
1070
    dec = ist->st->codec;
1071

    
1072
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1073

    
1074
    /* by default, we output a single frame */
1075
    nb_frames = 1;
1076

    
1077
    *frame_size = 0;
1078

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

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

    
1108
    formatted_picture = in_picture;
1109
    final_picture = formatted_picture;
1110
    resampling_dst = &ost->pict_tmp;
1111

    
1112
    resample_changed = ost->resample_width   != dec->width  ||
1113
                       ost->resample_height  != dec->height ||
1114
                       ost->resample_pix_fmt != dec->pix_fmt;
1115

    
1116
    if (resample_changed) {
1117
        av_log(NULL, AV_LOG_INFO,
1118
               "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1119
               ist->file_index, ist->index,
1120
               ost->resample_width, ost->resample_height, avcodec_get_pix_fmt_name(ost->resample_pix_fmt),
1121
               dec->width         , dec->height         , avcodec_get_pix_fmt_name(dec->pix_fmt));
1122
        if(!ost->video_resample)
1123
            ffmpeg_exit(1);
1124
    }
1125

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1300

    
1301
    oc = output_files[0];
1302

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

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

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

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

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

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

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

    
1380
        fflush(stderr);
1381
    }
1382

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1636
                        av_init_packet(&opkt);
1637

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1817

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2056
        codec = ost->st->codec;
2057
        icodec = ist->st->codec;
2058

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

    
2063
        ost->st->disposition = ist->st->disposition;
2064
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2065
        codec->chroma_sample_location = icodec->chroma_sample_location;
2066

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

    
2070
            if (extra_size > INT_MAX)
2071
                goto fail;
2072

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

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

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

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

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

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

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

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

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

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

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

    
2322
        int out_file_index = meta_data_maps[i][0].file;
2323
        int in_file_index = meta_data_maps[i][1].file;
2324
        if (in_file_index < 0 || out_file_index < 0)
2325
            continue;
2326
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2327
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2328

    
2329
        files[0] = output_files[out_file_index];
2330
        files[1] = input_files[in_file_index];
2331

    
2332
        for (j = 0; j < 2; j++) {
2333
            AVMetaDataMap *map = &meta_data_maps[i][j];
2334

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

    
2354
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2355
    }
2356

    
2357
    /* copy global metadata by default */
2358
    if (metadata_global_autocopy) {
2359

    
2360
        for (i = 0; i < nb_output_files; i++)
2361
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2362
                             AV_METADATA_DONT_OVERWRITE);
2363
    }
2364

    
2365
    /* copy chapters according to chapter maps */
2366
    for (i = 0; i < nb_chapter_maps; i++) {
2367
        int infile  = chapter_maps[i].in_file;
2368
        int outfile = chapter_maps[i].out_file;
2369

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

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

    
2391
            for (j = 0; j < nb_output_files; j++)
2392
                if ((ret = copy_chapters(i, j)) < 0)
2393
                    goto dump_format;
2394
            break;
2395
        }
2396

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

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

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

    
2435
    if (ret) {
2436
        fprintf(stderr, "%s\n", error);
2437
        goto fail;
2438
    }
2439

    
2440
    if (want_sdp) {
2441
        print_sdp(output_files, nb_output_files);
2442
    }
2443

    
2444
    if (verbose >= 0)
2445
        fprintf(stderr, "Press ctrl-c to stop encoding\n");
2446
    term_init();
2447

    
2448
    timer_start = av_gettime();
2449

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

    
2456
    redo:
2457
        ipts_min= 1e100;
2458
        opts_min= 1e100;
2459

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

    
2498
        /* finish if limit size exhausted */
2499
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2500
            break;
2501

    
2502
        /* read a frame from it and output it in the fifo */
2503
        is = input_files[file_index];
2504
        ret= av_read_frame(is, &pkt);
2505
        if(ret == AVERROR(EAGAIN)){
2506
            no_packet[file_index]=1;
2507
            no_packet_count++;
2508
            continue;
2509
        }
2510
        if (ret < 0) {
2511
            file_table[file_index].eof_reached = 1;
2512
            if (opt_shortest)
2513
                break;
2514
            else
2515
                continue;
2516
        }
2517

    
2518
        no_packet_count=0;
2519
        memset(no_packet, 0, sizeof(no_packet));
2520

    
2521
        if (do_pkt_dump) {
2522
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2523
                             is->streams[pkt.stream_index]);
2524
        }
2525
        /* the following test is needed in case new streams appear
2526
           dynamically in stream : we ignore them */
2527
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2528
            goto discard_packet;
2529
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2530
        ist = ist_table[ist_index];
2531
        if (ist->discard)
2532
            goto discard_packet;
2533

    
2534
        if (pkt.dts != AV_NOPTS_VALUE)
2535
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2536
        if (pkt.pts != AV_NOPTS_VALUE)
2537
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2538

    
2539
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2540
            && input_files_ts_scale[file_index][pkt.stream_index]){
2541
            if(pkt.pts != AV_NOPTS_VALUE)
2542
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2543
            if(pkt.dts != AV_NOPTS_VALUE)
2544
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2545
        }
2546

    
2547
//        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);
2548
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2549
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2550
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2551
            int64_t delta= pkt_dts - ist->next_pts;
2552
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2553
                input_files_ts_offset[ist->file_index]-= delta;
2554
                if (verbose > 2)
2555
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2556
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2557
                if(pkt.pts != AV_NOPTS_VALUE)
2558
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2559
            }
2560
        }
2561

    
2562
        /* finish if recording time exhausted */
2563
        if (recording_time != INT64_MAX &&
2564
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2565
            ist->is_past_recording_time = 1;
2566
            goto discard_packet;
2567
        }
2568

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

    
2572
            if (verbose >= 0)
2573
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2574
                        ist->file_index, ist->index);
2575
            if (exit_on_error)
2576
                ffmpeg_exit(1);
2577
            av_free_packet(&pkt);
2578
            goto redo;
2579
        }
2580

    
2581
    discard_packet:
2582
        av_free_packet(&pkt);
2583

    
2584
        /* dump report by using the output first video and audio streams */
2585
        print_report(output_files, ost_table, nb_ostreams, 0);
2586
    }
2587

    
2588
    /* at the end of stream, we must flush the decoder buffers */
2589
    for(i=0;i<nb_istreams;i++) {
2590
        ist = ist_table[i];
2591
        if (ist->decoding_needed) {
2592
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2593
        }
2594
    }
2595

    
2596
    term_exit();
2597

    
2598
    /* write the trailer if needed and close file */
2599
    for(i=0;i<nb_output_files;i++) {
2600
        os = output_files[i];
2601
        av_write_trailer(os);
2602
    }
2603

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

    
2607
    /* close each encoder */
2608
    for(i=0;i<nb_ostreams;i++) {
2609
        ost = ost_table[i];
2610
        if (ost->encoding_needed) {
2611
            av_freep(&ost->st->codec->stats_in);
2612
            avcodec_close(ost->st->codec);
2613
        }
2614
    }
2615

    
2616
    /* close each decoder */
2617
    for(i=0;i<nb_istreams;i++) {
2618
        ist = ist_table[i];
2619
        if (ist->decoding_needed) {
2620
            avcodec_close(ist->st->codec);
2621
        }
2622
    }
2623
#if CONFIG_AVFILTER
2624
    avfilter_graph_free(&graph);
2625
#endif
2626

    
2627
    /* finished ! */
2628
    ret = 0;
2629

    
2630
 fail:
2631
    av_freep(&bit_buffer);
2632
    av_free(file_table);
2633

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

    
2670
static void opt_format(const char *arg)
2671
{
2672
    last_asked_format = arg;
2673
}
2674

    
2675
static void opt_video_rc_override_string(const char *arg)
2676
{
2677
    video_rc_override_string = arg;
2678
}
2679

    
2680
static int opt_me_threshold(const char *opt, const char *arg)
2681
{
2682
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2683
    return 0;
2684
}
2685

    
2686
static int opt_verbose(const char *opt, const char *arg)
2687
{
2688
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2689
    return 0;
2690
}
2691

    
2692
static int opt_frame_rate(const char *opt, const char *arg)
2693
{
2694
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2695
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2696
        ffmpeg_exit(1);
2697
    }
2698
    return 0;
2699
}
2700

    
2701
static int opt_bitrate(const char *opt, const char *arg)
2702
{
2703
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2704

    
2705
    opt_default(opt, arg);
2706

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

    
2710
    return 0;
2711
}
2712

    
2713
static int opt_frame_crop(const char *opt, const char *arg)
2714
{
2715
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2716
    return AVERROR(EINVAL);
2717
}
2718

    
2719
static void opt_frame_size(const char *arg)
2720
{
2721
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2722
        fprintf(stderr, "Incorrect frame size\n");
2723
        ffmpeg_exit(1);
2724
    }
2725
}
2726

    
2727
static int opt_pad(const char *opt, const char *arg) {
2728
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2729
    return -1;
2730
}
2731

    
2732
static void opt_frame_pix_fmt(const char *arg)
2733
{
2734
    if (strcmp(arg, "list")) {
2735
        frame_pix_fmt = av_get_pix_fmt(arg);
2736
        if (frame_pix_fmt == PIX_FMT_NONE) {
2737
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2738
            ffmpeg_exit(1);
2739
        }
2740
    } else {
2741
        show_pix_fmts();
2742
        ffmpeg_exit(0);
2743
    }
2744
}
2745

    
2746
static void opt_frame_aspect_ratio(const char *arg)
2747
{
2748
    int x = 0, y = 0;
2749
    double ar = 0;
2750
    const char *p;
2751
    char *end;
2752

    
2753
    p = strchr(arg, ':');
2754
    if (p) {
2755
        x = strtol(arg, &end, 10);
2756
        if (end == p)
2757
            y = strtol(end+1, &end, 10);
2758
        if (x > 0 && y > 0)
2759
            ar = (double)x / (double)y;
2760
    } else
2761
        ar = strtod(arg, NULL);
2762

    
2763
    if (!ar) {
2764
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2765
        ffmpeg_exit(1);
2766
    }
2767
    frame_aspect_ratio = ar;
2768

    
2769
#if CONFIG_AVFILTER
2770
    x = vfilters ? strlen(vfilters) : 0;
2771
    vfilters = av_realloc(vfilters, x+100);
2772
    snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2773
#endif
2774
}
2775

    
2776
static int opt_metadata(const char *opt, const char *arg)
2777
{
2778
    char *mid= strchr(arg, '=');
2779

    
2780
    if(!mid){
2781
        fprintf(stderr, "Missing =\n");
2782
        ffmpeg_exit(1);
2783
    }
2784
    *mid++= 0;
2785

    
2786
    av_metadata_set2(&metadata, arg, mid, 0);
2787

    
2788
    return 0;
2789
}
2790

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

    
2801
static void opt_top_field_first(const char *arg)
2802
{
2803
    top_field_first= atoi(arg);
2804
}
2805

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

    
2816
static void opt_audio_sample_fmt(const char *arg)
2817
{
2818
    if (strcmp(arg, "list")) {
2819
        audio_sample_fmt = av_get_sample_fmt(arg);
2820
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2821
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2822
            ffmpeg_exit(1);
2823
        }
2824
    } else {
2825
        int i;
2826
        char fmt_str[128];
2827
        for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2828
            printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2829
        ffmpeg_exit(0);
2830
    }
2831
}
2832

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

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

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

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

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

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

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

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

    
2881
static void opt_data_codec(const char *arg)
2882
{
2883
    opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2884
}
2885

    
2886
static int opt_codec_tag(const char *opt, const char *arg)
2887
{
2888
    char *tail;
2889
    uint32_t *codec_tag;
2890

    
2891
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2892
                !strcmp(opt, "vtag") ? &video_codec_tag :
2893
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2894
    if (!codec_tag)
2895
        return -1;
2896

    
2897
    *codec_tag = strtol(arg, &tail, 0);
2898
    if (!tail || *tail)
2899
        *codec_tag = AV_RL32(arg);
2900

    
2901
    return 0;
2902
}
2903

    
2904
static void opt_map(const char *arg)
2905
{
2906
    AVStreamMap *m;
2907
    char *p;
2908

    
2909
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2910
    m = &stream_maps[nb_stream_maps-1];
2911

    
2912
    m->file_index = strtol(arg, &p, 0);
2913
    if (*p)
2914
        p++;
2915

    
2916
    m->stream_index = strtol(p, &p, 0);
2917
    if (*p) {
2918
        p++;
2919
        m->sync_file_index = strtol(p, &p, 0);
2920
        if (*p)
2921
            p++;
2922
        m->sync_stream_index = strtol(p, &p, 0);
2923
    } else {
2924
        m->sync_file_index = m->file_index;
2925
        m->sync_stream_index = m->stream_index;
2926
    }
2927
}
2928

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

    
2950
static void opt_map_metadata(const char *arg)
2951
{
2952
    AVMetaDataMap *m, *m1;
2953
    char *p;
2954

    
2955
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2956
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2957

    
2958
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
2959
    m->file = strtol(arg, &p, 0);
2960
    parse_meta_type(p, &m->type, &m->index, &p);
2961
    if (*p)
2962
        p++;
2963

    
2964
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2965
    m1->file = strtol(p, &p, 0);
2966
    parse_meta_type(p, &m1->type, &m1->index, &p);
2967

    
2968
    if (m->type == 'g' || m1->type == 'g')
2969
        metadata_global_autocopy = 0;
2970
    if (m->type == 's' || m1->type == 's')
2971
        metadata_streams_autocopy = 0;
2972
    if (m->type == 'c' || m1->type == 'c')
2973
        metadata_chapters_autocopy = 0;
2974
}
2975

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

    
2983
static void opt_map_chapters(const char *arg)
2984
{
2985
    AVChapterMap *c;
2986
    char *p;
2987

    
2988
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
2989
                              nb_chapter_maps + 1);
2990
    c = &chapter_maps[nb_chapter_maps - 1];
2991
    c->out_file = strtol(arg, &p, 0);
2992
    if (*p)
2993
        p++;
2994

    
2995
    c->in_file = strtol(p, &p, 0);
2996
}
2997

    
2998
static void opt_input_ts_scale(const char *arg)
2999
{
3000
    unsigned int stream;
3001
    double scale;
3002
    char *p;
3003

    
3004
    stream = strtol(arg, &p, 0);
3005
    if (*p)
3006
        p++;
3007
    scale= strtod(p, &p);
3008

    
3009
    if(stream >= MAX_STREAMS)
3010
        ffmpeg_exit(1);
3011

    
3012
    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);
3013
    input_files_ts_scale[nb_input_files][stream]= scale;
3014
}
3015

    
3016
static int opt_recording_time(const char *opt, const char *arg)
3017
{
3018
    recording_time = parse_time_or_die(opt, arg, 1);
3019
    return 0;
3020
}
3021

    
3022
static int opt_start_time(const char *opt, const char *arg)
3023
{
3024
    start_time = parse_time_or_die(opt, arg, 1);
3025
    return 0;
3026
}
3027

    
3028
static int opt_recording_timestamp(const char *opt, const char *arg)
3029
{
3030
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3031
    return 0;
3032
}
3033

    
3034
static int opt_input_ts_offset(const char *opt, const char *arg)
3035
{
3036
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3037
    return 0;
3038
}
3039

    
3040
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3041
{
3042
    const char *codec_string = encoder ? "encoder" : "decoder";
3043
    AVCodec *codec;
3044

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

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

    
3082
    if (last_asked_format) {
3083
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3084
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3085
            ffmpeg_exit(1);
3086
        }
3087
        last_asked_format = NULL;
3088
    }
3089

    
3090
    if (!strcmp(filename, "-"))
3091
        filename = "pipe:";
3092

    
3093
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3094
                    !strcmp(filename, "/dev/stdin");
3095

    
3096
    /* get default parameters from command line */
3097
    ic = avformat_alloc_context();
3098
    if (!ic) {
3099
        print_error(filename, AVERROR(ENOMEM));
3100
        ffmpeg_exit(1);
3101
    }
3102

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

    
3116
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3117

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

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

    
3159
    ic->loop_input = loop_input;
3160

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

    
3170
    timestamp = start_time;
3171
    /* add the stream start time */
3172
    if (ic->start_time != AV_NOPTS_VALUE)
3173
        timestamp += ic->start_time;
3174

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

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

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

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

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

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

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

    
3269
    nb_input_files++;
3270

    
3271
    video_channel = 0;
3272

    
3273
    av_freep(&video_codec_name);
3274
    av_freep(&audio_codec_name);
3275
    av_freep(&subtitle_codec_name);
3276
    uninit_opts();
3277
    init_opts();
3278
}
3279

    
3280
static void check_inputs(int *has_video_ptr,
3281
                         int *has_audio_ptr,
3282
                         int *has_subtitle_ptr,
3283
                         int *has_data_ptr)
3284
{
3285
    int has_video, has_audio, has_subtitle, has_data, i, j;
3286
    AVFormatContext *ic;
3287

    
3288
    has_video = 0;
3289
    has_audio = 0;
3290
    has_subtitle = 0;
3291
    has_data = 0;
3292

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

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

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

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

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

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

    
3357
    video_enc = st->codec;
3358

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

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

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

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

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

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

    
3396
        choose_pixel_fmt(st, codec);
3397

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3547
static void new_data_stream(AVFormatContext *oc, int file_idx)
3548
{
3549
    AVStream *st;
3550
    AVOutputStream *ost;
3551
    AVCodec *codec=NULL;
3552
    AVCodecContext *data_enc;
3553

    
3554
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3555
    if (!st) {
3556
        fprintf(stderr, "Could not alloc stream\n");
3557
        ffmpeg_exit(1);
3558
    }
3559
    ost = new_output_stream(oc, file_idx);
3560
    data_enc = st->codec;
3561
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3562
    if (!data_stream_copy) {
3563
        fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3564
        ffmpeg_exit(1);
3565
    }
3566
    avcodec_get_context_defaults3(st->codec, codec);
3567

    
3568
    data_enc->codec_type = AVMEDIA_TYPE_DATA;
3569

    
3570
    if (data_codec_tag)
3571
        data_enc->codec_tag= data_codec_tag;
3572

    
3573
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3574
        data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3575
        avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3576
    }
3577
    if (data_stream_copy) {
3578
        st->stream_copy = 1;
3579
    }
3580

    
3581
    data_disable = 0;
3582
    av_freep(&data_codec_name);
3583
    data_stream_copy = 0;
3584
}
3585

    
3586
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3587
{
3588
    AVStream *st;
3589
    AVOutputStream *ost;
3590
    AVCodec *codec=NULL;
3591
    AVCodecContext *subtitle_enc;
3592
    enum CodecID codec_id = CODEC_ID_NONE;
3593

    
3594
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3595
    if (!st) {
3596
        fprintf(stderr, "Could not alloc stream\n");
3597
        ffmpeg_exit(1);
3598
    }
3599
    ost = new_output_stream(oc, file_idx);
3600
    subtitle_enc = st->codec;
3601
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3602
    if(!subtitle_stream_copy){
3603
        if (subtitle_codec_name) {
3604
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3605
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3606
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3607
        } else {
3608
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3609
            codec = avcodec_find_encoder(codec_id);
3610
        }
3611
    }
3612
    avcodec_get_context_defaults3(st->codec, codec);
3613

    
3614
    ost->bitstream_filters = subtitle_bitstream_filters;
3615
    subtitle_bitstream_filters= NULL;
3616

    
3617
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3618

    
3619
    if(subtitle_codec_tag)
3620
        subtitle_enc->codec_tag= subtitle_codec_tag;
3621

    
3622
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3623
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3624
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3625
    }
3626
    if (subtitle_stream_copy) {
3627
        st->stream_copy = 1;
3628
    } else {
3629
        subtitle_enc->codec_id = codec_id;
3630
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3631
    }
3632

    
3633
    if (subtitle_language) {
3634
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3635
        av_freep(&subtitle_language);
3636
    }
3637

    
3638
    subtitle_disable = 0;
3639
    av_freep(&subtitle_codec_name);
3640
    subtitle_stream_copy = 0;
3641
}
3642

    
3643
static int opt_new_stream(const char *opt, const char *arg)
3644
{
3645
    AVFormatContext *oc;
3646
    int file_idx = nb_output_files - 1;
3647
    if (nb_output_files <= 0) {
3648
        fprintf(stderr, "At least one output file must be specified\n");
3649
        ffmpeg_exit(1);
3650
    }
3651
    oc = output_files[file_idx];
3652

    
3653
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3654
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3655
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3656
    else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3657
    else av_assert0(0);
3658
    return 0;
3659
}
3660

    
3661
/* arg format is "output-stream-index:streamid-value". */
3662
static int opt_streamid(const char *opt, const char *arg)
3663
{
3664
    int idx;
3665
    char *p;
3666
    char idx_str[16];
3667

    
3668
    av_strlcpy(idx_str, arg, sizeof(idx_str));
3669
    p = strchr(idx_str, ':');
3670
    if (!p) {
3671
        fprintf(stderr,
3672
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3673
                arg, opt);
3674
        ffmpeg_exit(1);
3675
    }
3676
    *p++ = '\0';
3677
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3678
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3679
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3680
    return 0;
3681
}
3682

    
3683
static void opt_output_file(const char *filename)
3684
{
3685
    AVFormatContext *oc;
3686
    int err, use_video, use_audio, use_subtitle, use_data;
3687
    int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3688
    AVFormatParameters params, *ap = &params;
3689
    AVOutputFormat *file_oformat;
3690

    
3691
    if (!strcmp(filename, "-"))
3692
        filename = "pipe:";
3693

    
3694
    oc = avformat_alloc_context();
3695
    if (!oc) {
3696
        print_error(filename, AVERROR(ENOMEM));
3697
        ffmpeg_exit(1);
3698
    }
3699

    
3700
    if (last_asked_format) {
3701
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3702
        if (!file_oformat) {
3703
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3704
            ffmpeg_exit(1);
3705
        }
3706
        last_asked_format = NULL;
3707
    } else {
3708
        file_oformat = av_guess_format(NULL, filename, NULL);
3709
        if (!file_oformat) {
3710
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3711
                    filename);
3712
            ffmpeg_exit(1);
3713
        }
3714
    }
3715

    
3716
    oc->oformat = file_oformat;
3717
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3718

    
3719
    if (!strcmp(file_oformat->name, "ffm") &&
3720
        av_strstart(filename, "http:", NULL)) {
3721
        /* special case for files sent to ffserver: we get the stream
3722
           parameters from ffserver */
3723
        int err = read_ffserver_streams(oc, filename);
3724
        if (err < 0) {
3725
            print_error(filename, err);
3726
            ffmpeg_exit(1);
3727
        }
3728
    } else {
3729
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3730
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3731
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3732
        use_data = data_stream_copy ||  data_codec_name; /* XXX once generic data codec will be available add a ->data_codec reference and use it here */
3733

    
3734
        /* disable if no corresponding type found and at least one
3735
           input file */
3736
        if (nb_input_files > 0) {
3737
            check_inputs(&input_has_video,
3738
                         &input_has_audio,
3739
                         &input_has_subtitle,
3740
                         &input_has_data);
3741

    
3742
            if (!input_has_video)
3743
                use_video = 0;
3744
            if (!input_has_audio)
3745
                use_audio = 0;
3746
            if (!input_has_subtitle)
3747
                use_subtitle = 0;
3748
            if (!input_has_data)
3749
                use_data = 0;
3750
        }
3751

    
3752
        /* manual disable */
3753
        if (audio_disable)    use_audio    = 0;
3754
        if (video_disable)    use_video    = 0;
3755
        if (subtitle_disable) use_subtitle = 0;
3756
        if (data_disable)     use_data     = 0;
3757

    
3758
        if (use_video)    new_video_stream(oc, nb_output_files);
3759
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3760
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3761
        if (use_data)     new_data_stream(oc, nb_output_files);
3762

    
3763
        oc->timestamp = recording_timestamp;
3764

    
3765
        av_metadata_copy(&oc->metadata, metadata, 0);
3766
        av_metadata_free(&metadata);
3767
    }
3768

    
3769
    output_files[nb_output_files++] = oc;
3770

    
3771
    /* check filename in case of an image number is expected */
3772
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3773
        if (!av_filename_number_test(oc->filename)) {
3774
            print_error(oc->filename, AVERROR(EINVAL));
3775
            ffmpeg_exit(1);
3776
        }
3777
    }
3778

    
3779
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3780
        /* test if it already exists to avoid loosing precious files */
3781
        if (!file_overwrite &&
3782
            (strchr(filename, ':') == NULL ||
3783
             filename[1] == ':' ||
3784
             av_strstart(filename, "file:", NULL))) {
3785
            if (avio_check(filename, 0) == 0) {
3786
                if (!using_stdin) {
3787
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3788
                    fflush(stderr);
3789
                    if (!read_yesno()) {
3790
                        fprintf(stderr, "Not overwriting - exiting\n");
3791
                        ffmpeg_exit(1);
3792
                    }
3793
                }
3794
                else {
3795
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3796
                    ffmpeg_exit(1);
3797
                }
3798
            }
3799
        }
3800

    
3801
        /* open the file */
3802
        if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3803
            print_error(filename, err);
3804
            ffmpeg_exit(1);
3805
        }
3806
    }
3807

    
3808
    memset(ap, 0, sizeof(*ap));
3809
    if (av_set_parameters(oc, ap) < 0) {
3810
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3811
                oc->filename);
3812
        ffmpeg_exit(1);
3813
    }
3814

    
3815
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3816
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3817
    oc->loop_output = loop_output;
3818
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3819

    
3820
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3821

    
3822
    av_freep(&forced_key_frames);
3823
    uninit_opts();
3824
    init_opts();
3825
}
3826

    
3827
/* same option as mencoder */
3828
static void opt_pass(const char *pass_str)
3829
{
3830
    int pass;
3831
    pass = atoi(pass_str);
3832
    if (pass != 1 && pass != 2) {
3833
        fprintf(stderr, "pass number can be only 1 or 2\n");
3834
        ffmpeg_exit(1);
3835
    }
3836
    do_pass = pass;
3837
}
3838

    
3839
static int64_t getutime(void)
3840
{
3841
#if HAVE_GETRUSAGE
3842
    struct rusage rusage;
3843

    
3844
    getrusage(RUSAGE_SELF, &rusage);
3845
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3846
#elif HAVE_GETPROCESSTIMES
3847
    HANDLE proc;
3848
    FILETIME c, e, k, u;
3849
    proc = GetCurrentProcess();
3850
    GetProcessTimes(proc, &c, &e, &k, &u);
3851
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3852
#else
3853
    return av_gettime();
3854
#endif
3855
}
3856

    
3857
static int64_t getmaxrss(void)
3858
{
3859
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3860
    struct rusage rusage;
3861
    getrusage(RUSAGE_SELF, &rusage);
3862
    return (int64_t)rusage.ru_maxrss * 1024;
3863
#elif HAVE_GETPROCESSMEMORYINFO
3864
    HANDLE proc;
3865
    PROCESS_MEMORY_COUNTERS memcounters;
3866
    proc = GetCurrentProcess();
3867
    memcounters.cb = sizeof(memcounters);
3868
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3869
    return memcounters.PeakPagefileUsage;
3870
#else
3871
    return 0;
3872
#endif
3873
}
3874

    
3875
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3876
{
3877
    int i;
3878
    const char *p = str;
3879
    for(i = 0;; i++) {
3880
        dest[i] = atoi(p);
3881
        if(i == 63)
3882
            break;
3883
        p = strchr(p, ',');
3884
        if(!p) {
3885
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3886
            ffmpeg_exit(1);
3887
        }
3888
        p++;
3889
    }
3890
}
3891

    
3892
static void opt_inter_matrix(const char *arg)
3893
{
3894
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3895
    parse_matrix_coeffs(inter_matrix, arg);
3896
}
3897

    
3898
static void opt_intra_matrix(const char *arg)
3899
{
3900
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3901
    parse_matrix_coeffs(intra_matrix, arg);
3902
}
3903

    
3904
static void show_usage(void)
3905
{
3906
    printf("Hyper fast Audio and Video encoder\n");
3907
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3908
    printf("\n");
3909
}
3910

    
3911
static void show_help(void)
3912
{
3913
    AVCodec *c;
3914
    AVOutputFormat *oformat = NULL;
3915

    
3916
    av_log_set_callback(log_callback_help);
3917
    show_usage();
3918
    show_help_options(options, "Main options:\n",
3919
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3920
    show_help_options(options, "\nAdvanced options:\n",
3921
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3922
                      OPT_EXPERT);
3923
    show_help_options(options, "\nVideo options:\n",
3924
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3925
                      OPT_VIDEO);
3926
    show_help_options(options, "\nAdvanced Video options:\n",
3927
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3928
                      OPT_VIDEO | OPT_EXPERT);
3929
    show_help_options(options, "\nAudio options:\n",
3930
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3931
                      OPT_AUDIO);
3932
    show_help_options(options, "\nAdvanced Audio options:\n",
3933
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3934
                      OPT_AUDIO | OPT_EXPERT);
3935
    show_help_options(options, "\nSubtitle options:\n",
3936
                      OPT_SUBTITLE | OPT_GRAB,
3937
                      OPT_SUBTITLE);
3938
    show_help_options(options, "\nAudio/Video grab options:\n",
3939
                      OPT_GRAB,
3940
                      OPT_GRAB);
3941
    printf("\n");
3942
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3943
    printf("\n");
3944

    
3945
    /* individual codec options */
3946
    c = NULL;
3947
    while ((c = av_codec_next(c))) {
3948
        if (c->priv_class) {
3949
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3950
            printf("\n");
3951
        }
3952
    }
3953

    
3954
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3955
    printf("\n");
3956

    
3957
    /* individual muxer options */
3958
    while ((oformat = av_oformat_next(oformat))) {
3959
        if (oformat->priv_class) {
3960
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3961
            printf("\n");
3962
        }
3963
    }
3964

    
3965
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3966
}
3967

    
3968
static void opt_target(const char *arg)
3969
{
3970
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3971
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3972

    
3973
    if(!strncmp(arg, "pal-", 4)) {
3974
        norm = PAL;
3975
        arg += 4;
3976
    } else if(!strncmp(arg, "ntsc-", 5)) {
3977
        norm = NTSC;
3978
        arg += 5;
3979
    } else if(!strncmp(arg, "film-", 5)) {
3980
        norm = FILM;
3981
        arg += 5;
3982
    } else {
3983
        int fr;
3984
        /* Calculate FR via float to avoid int overflow */
3985
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3986
        if(fr == 25000) {
3987
            norm = PAL;
3988
        } else if((fr == 29970) || (fr == 23976)) {
3989
            norm = NTSC;
3990
        } else {
3991
            /* Try to determine PAL/NTSC by peeking in the input files */
3992
            if(nb_input_files) {
3993
                int i, j;
3994
                for(j = 0; j < nb_input_files; j++) {
3995
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3996
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3997
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3998
                            continue;
3999
                        fr = c->time_base.den * 1000 / c->time_base.num;
4000
                        if(fr == 25000) {
4001
                            norm = PAL;
4002
                            break;
4003
                        } else if((fr == 29970) || (fr == 23976)) {
4004
                            norm = NTSC;
4005
                            break;
4006
                        }
4007
                    }
4008
                    if(norm != UNKNOWN)
4009
                        break;
4010
                }
4011
            }
4012
        }
4013
        if(verbose > 0 && norm != UNKNOWN)
4014
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4015
    }
4016

    
4017
    if(norm == UNKNOWN) {
4018
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4019
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4020
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4021
        ffmpeg_exit(1);
4022
    }
4023

    
4024
    if(!strcmp(arg, "vcd")) {
4025

    
4026
        opt_video_codec("mpeg1video");
4027
        opt_audio_codec("mp2");
4028
        opt_format("vcd");
4029

    
4030
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4031
        opt_frame_rate(NULL, frame_rates[norm]);
4032
        opt_default("g", norm == PAL ? "15" : "18");
4033

    
4034
        opt_default("b", "1150000");
4035
        opt_default("maxrate", "1150000");
4036
        opt_default("minrate", "1150000");
4037
        opt_default("bufsize", "327680"); // 40*1024*8;
4038

    
4039
        opt_default("ab", "224000");
4040
        audio_sample_rate = 44100;
4041
        audio_channels = 2;
4042

    
4043
        opt_default("packetsize", "2324");
4044
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4045

    
4046
        /* We have to offset the PTS, so that it is consistent with the SCR.
4047
           SCR starts at 36000, but the first two packs contain only padding
4048
           and the first pack from the other stream, respectively, may also have
4049
           been written before.
4050
           So the real data starts at SCR 36000+3*1200. */
4051
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4052
    } else if(!strcmp(arg, "svcd")) {
4053

    
4054
        opt_video_codec("mpeg2video");
4055
        opt_audio_codec("mp2");
4056
        opt_format("svcd");
4057

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

    
4062
        opt_default("b", "2040000");
4063
        opt_default("maxrate", "2516000");
4064
        opt_default("minrate", "0"); //1145000;
4065
        opt_default("bufsize", "1835008"); //224*1024*8;
4066
        opt_default("flags", "+scan_offset");
4067

    
4068

    
4069
        opt_default("ab", "224000");
4070
        audio_sample_rate = 44100;
4071

    
4072
        opt_default("packetsize", "2324");
4073

    
4074
    } else if(!strcmp(arg, "dvd")) {
4075

    
4076
        opt_video_codec("mpeg2video");
4077
        opt_audio_codec("ac3");
4078
        opt_format("dvd");
4079

    
4080
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4081
        opt_frame_rate(NULL, frame_rates[norm]);
4082
        opt_default("g", norm == PAL ? "15" : "18");
4083

    
4084
        opt_default("b", "6000000");
4085
        opt_default("maxrate", "9000000");
4086
        opt_default("minrate", "0"); //1500000;
4087
        opt_default("bufsize", "1835008"); //224*1024*8;
4088

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

    
4092
        opt_default("ab", "448000");
4093
        audio_sample_rate = 48000;
4094

    
4095
    } else if(!strncmp(arg, "dv", 2)) {
4096

    
4097
        opt_format("dv");
4098

    
4099
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4100
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4101
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4102
        opt_frame_rate(NULL, frame_rates[norm]);
4103

    
4104
        audio_sample_rate = 48000;
4105
        audio_channels = 2;
4106

    
4107
    } else {
4108
        fprintf(stderr, "Unknown target: %s\n", arg);
4109
        ffmpeg_exit(1);
4110
    }
4111
}
4112

    
4113
static void opt_vstats_file (const char *arg)
4114
{
4115
    av_free (vstats_filename);
4116
    vstats_filename=av_strdup (arg);
4117
}
4118

    
4119
static void opt_vstats (void)
4120
{
4121
    char filename[40];
4122
    time_t today2 = time(NULL);
4123
    struct tm *today = localtime(&today2);
4124

    
4125
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4126
             today->tm_sec);
4127
    opt_vstats_file(filename);
4128
}
4129

    
4130
static int opt_bsf(const char *opt, const char *arg)
4131
{
4132
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4133
    AVBitStreamFilterContext **bsfp;
4134

    
4135
    if(!bsfc){
4136
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4137
        ffmpeg_exit(1);
4138
    }
4139

    
4140
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4141
          *opt == 'a' ? &audio_bitstream_filters :
4142
                        &subtitle_bitstream_filters;
4143
    while(*bsfp)
4144
        bsfp= &(*bsfp)->next;
4145

    
4146
    *bsfp= bsfc;
4147

    
4148
    return 0;
4149
}
4150

    
4151
static int opt_preset(const char *opt, const char *arg)
4152
{
4153
    FILE *f=NULL;
4154
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4155
    char *codec_name = *opt == 'v' ? video_codec_name :
4156
                       *opt == 'a' ? audio_codec_name :
4157
                                     subtitle_codec_name;
4158

    
4159
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4160
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4161
        ffmpeg_exit(1);
4162
    }
4163

    
4164
    while(!feof(f)){
4165
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4166
        if(line[0] == '#' && !e)
4167
            continue;
4168
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4169
        if(e){
4170
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4171
            ffmpeg_exit(1);
4172
        }
4173
        if(!strcmp(tmp, "acodec")){
4174
            opt_audio_codec(tmp2);
4175
        }else if(!strcmp(tmp, "vcodec")){
4176
            opt_video_codec(tmp2);
4177
        }else if(!strcmp(tmp, "scodec")){
4178
            opt_subtitle_codec(tmp2);
4179
        }else if(!strcmp(tmp, "dcodec")){
4180
            opt_data_codec(tmp2);
4181
        }else if(opt_default(tmp, tmp2) < 0){
4182
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4183
            ffmpeg_exit(1);
4184
        }
4185
    }
4186

    
4187
    fclose(f);
4188

    
4189
    return 0;
4190
}
4191

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

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

    
4285
    /* audio options */
4286
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4287
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4288
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4289
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4290
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4291
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4292
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4293
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4294
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4295
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4296
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4297
    { "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" },
4298

    
4299
    /* subtitle options */
4300
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4301
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4302
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4303
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4304
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4305

    
4306
    /* grab options */
4307
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4308
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4309
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4310

    
4311
    /* muxer options */
4312
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4313
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4314

    
4315
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4316
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4317
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4318

    
4319
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4320
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4321
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4322
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4323
    /* data codec support */
4324
    { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4325

    
4326
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4327
    { NULL, },
4328
};
4329

    
4330
int main(int argc, char **argv)
4331
{
4332
    int64_t ti;
4333

    
4334
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4335

    
4336
    avcodec_register_all();
4337
#if CONFIG_AVDEVICE
4338
    avdevice_register_all();
4339
#endif
4340
#if CONFIG_AVFILTER
4341
    avfilter_register_all();
4342
#endif
4343
    av_register_all();
4344

    
4345
    avio_set_interrupt_cb(decode_interrupt_cb);
4346

    
4347
    init_opts();
4348

    
4349
    show_banner();
4350

    
4351
    /* parse options */
4352
    parse_options(argc, argv, options, opt_output_file);
4353

    
4354
    if(nb_output_files <= 0 && nb_input_files == 0) {
4355
        show_usage();
4356
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4357
        ffmpeg_exit(1);
4358
    }
4359

    
4360
    /* file converter / grab */
4361
    if (nb_output_files <= 0) {
4362
        fprintf(stderr, "At least one output file must be specified\n");
4363
        ffmpeg_exit(1);
4364
    }
4365

    
4366
    if (nb_input_files == 0) {
4367
        fprintf(stderr, "At least one input file must be specified\n");
4368
        ffmpeg_exit(1);
4369
    }
4370

    
4371
    ti = getutime();
4372
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4373
                  stream_maps, nb_stream_maps) < 0)
4374
        ffmpeg_exit(1);
4375
    ti = getutime() - ti;
4376
    if (do_benchmark) {
4377
        int maxrss = getmaxrss() / 1024;
4378
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4379
    }
4380

    
4381
    return ffmpeg_exit(0);
4382
}