Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 1435f2fa

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
/* needed for usleep() */
23
#define _XOPEN_SOURCE 600
24

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

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

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

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

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

    
77
#include "cmdutils.h"
78

    
79
#include "libavutil/avassert.h"
80

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

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

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

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

    
106
static const OptionDef options[];
107

    
108
#define MAX_FILES 100
109
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
110

    
111
#define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h
112

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

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

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

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

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

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

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

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

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

    
189
static int data_disable = 0;
190
static char *data_codec_name = NULL;
191
static unsigned int data_codec_tag = 0;
192

    
193
static float mux_preload= 0.5;
194
static float mux_max_delay= 0.7;
195

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

    
224
static int rate_emu = 0;
225

    
226
static int  video_channel = 0;
227
static char *video_standard;
228

    
229
static int audio_volume = 256;
230

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

    
246
static float dts_delta_threshold = 10;
247

    
248
static int64_t timer_start;
249

    
250
static uint8_t *audio_buf;
251
static uint8_t *audio_out;
252
static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
253

    
254
static short *samples;
255

    
256
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
257
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
258
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
259

    
260
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
261

    
262
struct AVInputStream;
263

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

    
285
    /* full frame size of first frame */
286
    int original_height;
287
    int original_width;
288

    
289
    /* forced key frames */
290
    int64_t *forced_kf_pts;
291
    int forced_kf_count;
292
    int forced_kf_index;
293

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

    
305
   int sws_flags;
306
} AVOutputStream;
307

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

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

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

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

    
343
#if CONFIG_AVFILTER
344

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

    
356
    graph = avfilter_graph_alloc();
357

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

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

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

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

    
390
    snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
391
    graph->scale_sws_opts = av_strdup(args);
392

    
393
    if (vfilters) {
394
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
395
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
396

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

    
402
        inputs->name    = av_strdup("out");
403
        inputs->filter_ctx = ist->output_video_filter;
404
        inputs->pad_idx = 0;
405
        inputs->next    = NULL;
406

    
407
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
408
            return ret;
409
        av_freep(&vfilters);
410
    } else {
411
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
412
            return ret;
413
    }
414

    
415
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
416
        return ret;
417

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

    
423
    return 0;
424
}
425
#endif /* CONFIG_AVFILTER */
426

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

    
432
static volatile int received_sigterm = 0;
433

    
434
static void
435
sigterm_handler(int sig)
436
{
437
    received_sigterm = sig;
438
    term_exit();
439
}
440

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

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

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

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

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

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

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

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

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

    
500
    av_free(video_standard);
501

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

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

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

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

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

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

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

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

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

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

    
621
    ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
622
    return ost;
623
}
624

    
625
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
626
{
627
    int i, err;
628
    AVFormatContext *ic;
629
    int nopts = 0;
630

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

    
640
        s->nb_streams++;
641

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

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

    
666
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
667
            nopts = 1;
668

    
669
        new_output_stream(s, nb_output_files);
670
    }
671

    
672
    if (!nopts)
673
        s->timestamp = av_gettime();
674

    
675
    av_close_input_file(ic);
676
    return 0;
677
}
678

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

    
686
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
687
    int ret;
688

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

    
708
        bsfc= bsfc->next;
709
    }
710

    
711
    ret= av_interleaved_write_frame(s, pkt);
712
    if(ret < 0){
713
        print_error("av_interleaved_write_frame()", ret);
714
        ffmpeg_exit(1);
715
    }
716
}
717

    
718
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
719

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

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

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

    
743
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
744
    if(coded_bps > 8*osize)
745
        audio_out_size= audio_out_size * coded_bps / (8*osize);
746
    audio_out_size += FF_MIN_BUFFER_SIZE;
747

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

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

    
760
    if (enc->channels != dec->channels)
761
        ost->audio_resample = 1;
762

    
763
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
764
                       ost->resample_channels    != dec->channels   ||
765
                       ost->resample_sample_rate != dec->sample_rate;
766

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

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

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

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

    
840
                    if(byte_delta > allocated_for_size - size){
841
                        allocated_for_size= byte_delta + (int64_t)size;
842
                        goto need_realloc;
843
                    }
844
                    ist->is_start=0;
845

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

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

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

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

    
902
        frame_bytes = enc->frame_size * osize * enc->channels;
903

    
904
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
905
            AVPacket pkt;
906
            av_init_packet(&pkt);
907

    
908
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
909

    
910
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
911

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

    
927
            ost->sync_opts += enc->frame_size;
928
        }
929
    } else {
930
        AVPacket pkt;
931
        av_init_packet(&pkt);
932

    
933
        ost->sync_opts += size_out / (osize * enc->channels);
934

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

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

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

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

    
971
    dec = ist->st->codec;
972

    
973
    /* deinterlace : must be done before any resize */
974
    if (do_deinterlace) {
975
        int size;
976

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

    
983
        picture2 = &picture_tmp;
984
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
985

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

    
998
    if (picture != picture2)
999
        *picture = *picture2;
1000
    *bufp = buf;
1001
}
1002

    
1003
/* we begin to correct av delay at this threshold */
1004
#define AV_DELAY_MAX 0.100
1005

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

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

    
1025
    enc = ost->st->codec;
1026

    
1027
    if (!subtitle_out) {
1028
        subtitle_out = av_malloc(subtitle_out_max_size);
1029
    }
1030

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

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

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

    
1069
static int bit_buffer_size= 1024*256;
1070
static uint8_t *bit_buffer= NULL;
1071

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

    
1083
    enc = ost->st->codec;
1084
    dec = ist->st->codec;
1085

    
1086
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1087

    
1088
    /* by default, we output a single frame */
1089
    nb_frames = 1;
1090

    
1091
    *frame_size = 0;
1092

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

    
1118
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1119
    if (nb_frames <= 0)
1120
        return;
1121

    
1122
    formatted_picture = in_picture;
1123
    final_picture = formatted_picture;
1124
    padding_src = formatted_picture;
1125
    resampling_dst = &ost->pict_tmp;
1126

    
1127
    if (   ost->resample_height != ist->st->codec->height
1128
        || ost->resample_width  != ist->st->codec->width
1129
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1130

    
1131
        fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width,     ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1132
        if(!ost->video_resample)
1133
            ffmpeg_exit(1);
1134
    }
1135

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

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

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

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

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

    
1186
            big_picture= *final_picture;
1187
            /* better than nothing: use input picture interlaced
1188
               settings */
1189
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1190
            if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1191
                if(top_field_first == -1)
1192
                    big_picture.top_field_first = in_picture->top_field_first;
1193
                else
1194
                    big_picture.top_field_first = top_field_first;
1195
            }
1196

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

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

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

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

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

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

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

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

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

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

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

    
1314

    
1315
    oc = output_files[0];
1316

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

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

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

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

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

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

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

    
1395
        fflush(stderr);
1396
    }
1397

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

    
1410
static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1411
{
1412
    int fill_char = 0x00;
1413
    if (sample_fmt == AV_SAMPLE_FMT_U8)
1414
        fill_char = 0x80;
1415
    memset(buf, fill_char, size);
1416
}
1417

    
1418
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1419
static int output_packet(AVInputStream *ist, int ist_index,
1420
                         AVOutputStream **ost_table, int nb_ostreams,
1421
                         const AVPacket *pkt)
1422
{
1423
    AVFormatContext *os;
1424
    AVOutputStream *ost;
1425
    int ret, i;
1426
    int got_picture;
1427
    AVFrame picture;
1428
    void *buffer_to_free;
1429
    static unsigned int samples_size= 0;
1430
    AVSubtitle subtitle, *subtitle_to_free;
1431
    int64_t pkt_pts = AV_NOPTS_VALUE;
1432
#if CONFIG_AVFILTER
1433
    int frame_available;
1434
#endif
1435

    
1436
    AVPacket avpkt;
1437
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1438

    
1439
    if(ist->next_pts == AV_NOPTS_VALUE)
1440
        ist->next_pts= ist->pts;
1441

    
1442
    if (pkt == NULL) {
1443
        /* EOF handling */
1444
        av_init_packet(&avpkt);
1445
        avpkt.data = NULL;
1446
        avpkt.size = 0;
1447
        goto handle_eof;
1448
    } else {
1449
        avpkt = *pkt;
1450
    }
1451

    
1452
    if(pkt->dts != AV_NOPTS_VALUE)
1453
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1454
    if(pkt->pts != AV_NOPTS_VALUE)
1455
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1456

    
1457
    //while we have more to decode or while the decoder did output something on EOF
1458
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1459
        uint8_t *data_buf, *decoded_data_buf;
1460
        int data_size, decoded_data_size;
1461
    handle_eof:
1462
        ist->pts= ist->next_pts;
1463

    
1464
        if(avpkt.size && avpkt.size != pkt->size &&
1465
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1466
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1467
            ist->showed_multi_packet_warning=1;
1468
        }
1469

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

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

    
1563
        buffer_to_free = NULL;
1564
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1565
            pre_process_video_frame(ist, (AVPicture *)&picture,
1566
                                    &buffer_to_free);
1567
        }
1568

    
1569
#if CONFIG_AVFILTER
1570
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1571
            AVRational sar;
1572
            if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1573
            else                                  sar = ist->st->codec->sample_aspect_ratio;
1574
            // add it to be filtered
1575
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1576
                                     ist->pts,
1577
                                     sar);
1578
        }
1579
#endif
1580

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

    
1595
        /* frame rate emulation */
1596
        if (rate_emu) {
1597
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1598
            int64_t now = av_gettime() - ist->start;
1599
            if (pts > now)
1600
                usleep(pts - now);
1601
        }
1602
#if CONFIG_AVFILTER
1603
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1604
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1605
#endif
1606
        /* if output time reached then transcode raw format,
1607
           encode packets and output them */
1608
        if (start_time == 0 || ist->pts >= start_time)
1609
#if CONFIG_AVFILTER
1610
        while (frame_available) {
1611
            AVRational ist_pts_tb;
1612
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1613
                get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1614
            if (ist->picref)
1615
                ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1616
#endif
1617
            for(i=0;i<nb_ostreams;i++) {
1618
                int frame_size;
1619

    
1620
                ost = ost_table[i];
1621
                if (ost->source_index == ist_index) {
1622
                    os = output_files[ost->file_index];
1623

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

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

    
1654
                        av_init_packet(&opkt);
1655

    
1656
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1657
                            continue;
1658

    
1659
                        /* no reencoding needed : output the packet directly */
1660
                        /* force the input stream PTS */
1661

    
1662
                        avcodec_get_frame_defaults(&avframe);
1663
                        ost->st->codec->coded_frame= &avframe;
1664
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1665

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

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

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

    
1685
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1686
                        opkt.flags= pkt->flags;
1687

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

    
1700
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1701
                        ost->st->codec->frame_number++;
1702
                        ost->frame_number++;
1703
                        av_free_packet(&opkt);
1704
                    }
1705
                }
1706
            }
1707

    
1708
#if CONFIG_AVFILTER
1709
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1710
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1711
            if(ist->picref)
1712
                avfilter_unref_buffer(ist->picref);
1713
        }
1714
#endif
1715
        av_free(buffer_to_free);
1716
        /* XXX: allocate the subtitles in the codec ? */
1717
        if (subtitle_to_free) {
1718
            avsubtitle_free(subtitle_to_free);
1719
            subtitle_to_free = NULL;
1720
        }
1721
    }
1722
 discard_packet:
1723
    if (pkt == NULL) {
1724
        /* EOF handling */
1725

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

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

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

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

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

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

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

    
1808
    return 0;
1809
 fail_decode:
1810
    return -1;
1811
}
1812

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

    
1817
    av_sdp_create(avc, n, sdp, sizeof(sdp));
1818
    printf("SDP:\n%s\n", sdp);
1819
    fflush(stdout);
1820
}
1821

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

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

    
1835

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

    
1841
        out_ch = av_mallocz(sizeof(AVChapter));
1842
        if (!out_ch)
1843
            return AVERROR(ENOMEM);
1844

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

    
1850
        if (metadata_chapters_autocopy)
1851
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1852

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2075
        codec = ost->st->codec;
2076
        icodec = ist->st->codec;
2077

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

    
2082
        ost->st->disposition = ist->st->disposition;
2083
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2084
        codec->chroma_sample_location = icodec->chroma_sample_location;
2085

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

    
2089
            if (extra_size > INT_MAX)
2090
                goto fail;
2091

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

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

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

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

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

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

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

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

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

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

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

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

    
2344
        int out_file_index = meta_data_maps[i][0].file;
2345
        int in_file_index = meta_data_maps[i][1].file;
2346
        if (in_file_index < 0 || out_file_index < 0)
2347
            continue;
2348
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2349
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2350

    
2351
        files[0] = output_files[out_file_index];
2352
        files[1] = input_files[in_file_index];
2353

    
2354
        for (j = 0; j < 2; j++) {
2355
            AVMetaDataMap *map = &meta_data_maps[i][j];
2356

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

    
2376
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2377
    }
2378

    
2379
    /* copy global metadata by default */
2380
    if (metadata_global_autocopy) {
2381

    
2382
        for (i = 0; i < nb_output_files; i++)
2383
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2384
                             AV_METADATA_DONT_OVERWRITE);
2385
    }
2386

    
2387
    /* copy chapters according to chapter maps */
2388
    for (i = 0; i < nb_chapter_maps; i++) {
2389
        int infile  = chapter_maps[i].in_file;
2390
        int outfile = chapter_maps[i].out_file;
2391

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

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

    
2413
            for (j = 0; j < nb_output_files; j++)
2414
                if ((ret = copy_chapters(i, j)) < 0)
2415
                    goto dump_format;
2416
            break;
2417
        }
2418

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

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

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

    
2457
    if (ret) {
2458
        fprintf(stderr, "%s\n", error);
2459
        goto fail;
2460
    }
2461

    
2462
    if (want_sdp) {
2463
        print_sdp(output_files, nb_output_files);
2464
    }
2465

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

    
2476
    timer_start = av_gettime();
2477

    
2478
    for(; received_sigterm == 0;) {
2479
        int file_index, ist_index;
2480
        AVPacket pkt;
2481
        double ipts_min;
2482
        double opts_min;
2483

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

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

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

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

    
2555
        no_packet_count=0;
2556
        memset(no_packet, 0, sizeof(no_packet));
2557

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

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

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

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

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

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

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

    
2618
    discard_packet:
2619
        av_free_packet(&pkt);
2620

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

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

    
2633
    term_exit();
2634

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

    
2641
    /* dump report by using the first video and audio streams */
2642
    print_report(output_files, ost_table, nb_ostreams, 1);
2643

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

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

    
2664
    /* finished ! */
2665
    ret = 0;
2666

    
2667
 fail:
2668
    av_freep(&bit_buffer);
2669
    av_free(file_table);
2670

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

    
2707
static void opt_format(const char *arg)
2708
{
2709
    last_asked_format = arg;
2710
}
2711

    
2712
static void opt_video_rc_override_string(const char *arg)
2713
{
2714
    video_rc_override_string = arg;
2715
}
2716

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

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

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

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

    
2742
    opt_default(opt, arg);
2743

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

    
2747
    return 0;
2748
}
2749

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

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

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

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

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

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

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

    
2806
    x = vfilters ? strlen(vfilters) : 0;
2807
    vfilters = av_realloc(vfilters, x+100);
2808
    snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2809
}
2810

    
2811
static int opt_metadata(const char *opt, const char *arg)
2812
{
2813
    char *mid= strchr(arg, '=');
2814

    
2815
    if(!mid){
2816
        fprintf(stderr, "Missing =\n");
2817
        ffmpeg_exit(1);
2818
    }
2819
    *mid++= 0;
2820

    
2821
    av_metadata_set2(&metadata, arg, mid, 0);
2822

    
2823
    return 0;
2824
}
2825

    
2826
static void opt_qscale(const char *arg)
2827
{
2828
    video_qscale = atof(arg);
2829
    if (video_qscale <= 0 ||
2830
        video_qscale > 255) {
2831
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2832
        ffmpeg_exit(1);
2833
    }
2834
}
2835

    
2836
static void opt_top_field_first(const char *arg)
2837
{
2838
    top_field_first= atoi(arg);
2839
}
2840

    
2841
static int opt_thread_count(const char *opt, const char *arg)
2842
{
2843
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2844
#if !HAVE_THREADS
2845
    if (verbose >= 0)
2846
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2847
#endif
2848
    return 0;
2849
}
2850

    
2851
static void opt_audio_sample_fmt(const char *arg)
2852
{
2853
    if (strcmp(arg, "list")) {
2854
        audio_sample_fmt = av_get_sample_fmt(arg);
2855
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2856
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2857
            ffmpeg_exit(1);
2858
        }
2859
    } else {
2860
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2861
        ffmpeg_exit(0);
2862
    }
2863
}
2864

    
2865
static int opt_audio_rate(const char *opt, const char *arg)
2866
{
2867
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2868
    return 0;
2869
}
2870

    
2871
static int opt_audio_channels(const char *opt, const char *arg)
2872
{
2873
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2874
    return 0;
2875
}
2876

    
2877
static void opt_video_channel(const char *arg)
2878
{
2879
    video_channel = strtol(arg, NULL, 0);
2880
}
2881

    
2882
static void opt_video_standard(const char *arg)
2883
{
2884
    video_standard = av_strdup(arg);
2885
}
2886

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

    
2898
static void opt_audio_codec(const char *arg)
2899
{
2900
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2901
}
2902

    
2903
static void opt_video_codec(const char *arg)
2904
{
2905
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2906
}
2907

    
2908
static void opt_subtitle_codec(const char *arg)
2909
{
2910
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2911
}
2912

    
2913
static void opt_data_codec(const char *arg)
2914
{
2915
    opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2916
}
2917

    
2918
static int opt_codec_tag(const char *opt, const char *arg)
2919
{
2920
    char *tail;
2921
    uint32_t *codec_tag;
2922

    
2923
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2924
                !strcmp(opt, "vtag") ? &video_codec_tag :
2925
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2926
    if (!codec_tag)
2927
        return -1;
2928

    
2929
    *codec_tag = strtol(arg, &tail, 0);
2930
    if (!tail || *tail)
2931
        *codec_tag = AV_RL32(arg);
2932

    
2933
    return 0;
2934
}
2935

    
2936
static void opt_map(const char *arg)
2937
{
2938
    AVStreamMap *m;
2939
    char *p;
2940

    
2941
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2942
    m = &stream_maps[nb_stream_maps-1];
2943

    
2944
    m->file_index = strtol(arg, &p, 0);
2945
    if (*p)
2946
        p++;
2947

    
2948
    m->stream_index = strtol(p, &p, 0);
2949
    if (*p) {
2950
        p++;
2951
        m->sync_file_index = strtol(p, &p, 0);
2952
        if (*p)
2953
            p++;
2954
        m->sync_stream_index = strtol(p, &p, 0);
2955
    } else {
2956
        m->sync_file_index = m->file_index;
2957
        m->sync_stream_index = m->stream_index;
2958
    }
2959
}
2960

    
2961
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2962
{
2963
    *endptr = arg;
2964
    if (*arg == ',') {
2965
        *type = *(++arg);
2966
        switch (*arg) {
2967
        case 'g':
2968
            break;
2969
        case 's':
2970
        case 'c':
2971
        case 'p':
2972
            *index = strtol(++arg, endptr, 0);
2973
            break;
2974
        default:
2975
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2976
            ffmpeg_exit(1);
2977
        }
2978
    } else
2979
        *type = 'g';
2980
}
2981

    
2982
static void opt_map_metadata(const char *arg)
2983
{
2984
    AVMetaDataMap *m, *m1;
2985
    char *p;
2986

    
2987
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2988
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2989

    
2990
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
2991
    m->file = strtol(arg, &p, 0);
2992
    parse_meta_type(p, &m->type, &m->index, &p);
2993
    if (*p)
2994
        p++;
2995

    
2996
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2997
    m1->file = strtol(p, &p, 0);
2998
    parse_meta_type(p, &m1->type, &m1->index, &p);
2999

    
3000
    if (m->type == 'g' || m1->type == 'g')
3001
        metadata_global_autocopy = 0;
3002
    if (m->type == 's' || m1->type == 's')
3003
        metadata_streams_autocopy = 0;
3004
    if (m->type == 'c' || m1->type == 'c')
3005
        metadata_chapters_autocopy = 0;
3006
}
3007

    
3008
static void opt_map_meta_data(const char *arg)
3009
{
3010
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3011
                    "Use -map_metadata instead.\n");
3012
    opt_map_metadata(arg);
3013
}
3014

    
3015
static void opt_map_chapters(const char *arg)
3016
{
3017
    AVChapterMap *c;
3018
    char *p;
3019

    
3020
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3021
                              nb_chapter_maps + 1);
3022
    c = &chapter_maps[nb_chapter_maps - 1];
3023
    c->out_file = strtol(arg, &p, 0);
3024
    if (*p)
3025
        p++;
3026

    
3027
    c->in_file = strtol(p, &p, 0);
3028
}
3029

    
3030
static void opt_input_ts_scale(const char *arg)
3031
{
3032
    unsigned int stream;
3033
    double scale;
3034
    char *p;
3035

    
3036
    stream = strtol(arg, &p, 0);
3037
    if (*p)
3038
        p++;
3039
    scale= strtod(p, &p);
3040

    
3041
    if(stream >= MAX_STREAMS)
3042
        ffmpeg_exit(1);
3043

    
3044
    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);
3045
    input_files_ts_scale[nb_input_files][stream]= scale;
3046
}
3047

    
3048
static int opt_recording_time(const char *opt, const char *arg)
3049
{
3050
    recording_time = parse_time_or_die(opt, arg, 1);
3051
    return 0;
3052
}
3053

    
3054
static int opt_start_time(const char *opt, const char *arg)
3055
{
3056
    start_time = parse_time_or_die(opt, arg, 1);
3057
    return 0;
3058
}
3059

    
3060
static int opt_recording_timestamp(const char *opt, const char *arg)
3061
{
3062
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3063
    return 0;
3064
}
3065

    
3066
static int opt_input_ts_offset(const char *opt, const char *arg)
3067
{
3068
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3069
    return 0;
3070
}
3071

    
3072
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3073
{
3074
    const char *codec_string = encoder ? "encoder" : "decoder";
3075
    AVCodec *codec;
3076

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

    
3106
static void opt_input_file(const char *filename)
3107
{
3108
    AVFormatContext *ic;
3109
    AVFormatParameters params, *ap = &params;
3110
    AVInputFormat *file_iformat = NULL;
3111
    int err, i, ret, rfps, rfps_base;
3112
    int64_t timestamp;
3113

    
3114
    if (last_asked_format) {
3115
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3116
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3117
            ffmpeg_exit(1);
3118
        }
3119
        last_asked_format = NULL;
3120
    }
3121

    
3122
    if (!strcmp(filename, "-"))
3123
        filename = "pipe:";
3124

    
3125
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3126
                    !strcmp(filename, "/dev/stdin");
3127

    
3128
    /* get default parameters from command line */
3129
    ic = avformat_alloc_context();
3130
    if (!ic) {
3131
        print_error(filename, AVERROR(ENOMEM));
3132
        ffmpeg_exit(1);
3133
    }
3134

    
3135
    memset(ap, 0, sizeof(*ap));
3136
    ap->prealloced_context = 1;
3137
    ap->sample_rate = audio_sample_rate;
3138
    ap->channels = audio_channels;
3139
    ap->time_base.den = frame_rate.num;
3140
    ap->time_base.num = frame_rate.den;
3141
    ap->width = frame_width;
3142
    ap->height = frame_height;
3143
    ap->pix_fmt = frame_pix_fmt;
3144
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3145
    ap->channel = video_channel;
3146
    ap->standard = video_standard;
3147

    
3148
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3149

    
3150
    ic->video_codec_id   =
3151
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3152
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3153
    ic->audio_codec_id   =
3154
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3155
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3156
    ic->subtitle_codec_id=
3157
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3158
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3159
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3160

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

    
3191
    ic->loop_input = loop_input;
3192

    
3193
    /* If not enough info to get the stream parameters, we decode the
3194
       first frames to get it. (used in mpeg case for example) */
3195
    ret = av_find_stream_info(ic);
3196
    if (ret < 0 && verbose >= 0) {
3197
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3198
        av_close_input_file(ic);
3199
        ffmpeg_exit(1);
3200
    }
3201

    
3202
    timestamp = start_time;
3203
    /* add the stream start time */
3204
    if (ic->start_time != AV_NOPTS_VALUE)
3205
        timestamp += ic->start_time;
3206

    
3207
    /* if seeking requested, we execute it */
3208
    if (start_time != 0) {
3209
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3210
        if (ret < 0) {
3211
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3212
                    filename, (double)timestamp / AV_TIME_BASE);
3213
        }
3214
        /* reset seek info */
3215
        start_time = 0;
3216
    }
3217

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

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

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

    
3269
                    (float)rfps / rfps_base, rfps, rfps_base);
3270
            }
3271
            /* update the current frame rate to match the stream frame rate */
3272
            frame_rate.num = rfps;
3273
            frame_rate.den = rfps_base;
3274

    
3275
            if(video_disable)
3276
                st->discard= AVDISCARD_ALL;
3277
            else if(video_discard)
3278
                st->discard= video_discard;
3279
            break;
3280
        case AVMEDIA_TYPE_DATA:
3281
            break;
3282
        case AVMEDIA_TYPE_SUBTITLE:
3283
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3284
            if(subtitle_disable)
3285
                st->discard = AVDISCARD_ALL;
3286
            break;
3287
        case AVMEDIA_TYPE_ATTACHMENT:
3288
        case AVMEDIA_TYPE_UNKNOWN:
3289
            break;
3290
        default:
3291
            abort();
3292
        }
3293
    }
3294

    
3295
    input_files[nb_input_files] = ic;
3296
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3297
    /* dump the file content */
3298
    if (verbose >= 0)
3299
        av_dump_format(ic, nb_input_files, filename, 0);
3300

    
3301
    nb_input_files++;
3302

    
3303
    video_channel = 0;
3304

    
3305
    av_freep(&video_codec_name);
3306
    av_freep(&audio_codec_name);
3307
    av_freep(&subtitle_codec_name);
3308
}
3309

    
3310
static void check_inputs(int *has_video_ptr,
3311
                         int *has_audio_ptr,
3312
                         int *has_subtitle_ptr,
3313
                         int *has_data_ptr)
3314
{
3315
    int has_video, has_audio, has_subtitle, has_data, i, j;
3316
    AVFormatContext *ic;
3317

    
3318
    has_video = 0;
3319
    has_audio = 0;
3320
    has_subtitle = 0;
3321
    has_data = 0;
3322

    
3323
    for(j=0;j<nb_input_files;j++) {
3324
        ic = input_files[j];
3325
        for(i=0;i<ic->nb_streams;i++) {
3326
            AVCodecContext *enc = ic->streams[i]->codec;
3327
            switch(enc->codec_type) {
3328
            case AVMEDIA_TYPE_AUDIO:
3329
                has_audio = 1;
3330
                break;
3331
            case AVMEDIA_TYPE_VIDEO:
3332
                has_video = 1;
3333
                break;
3334
            case AVMEDIA_TYPE_SUBTITLE:
3335
                has_subtitle = 1;
3336
                break;
3337
            case AVMEDIA_TYPE_DATA:
3338
            case AVMEDIA_TYPE_ATTACHMENT:
3339
            case AVMEDIA_TYPE_UNKNOWN:
3340
                has_data = 1;
3341
                break;
3342
            default:
3343
                abort();
3344
            }
3345
        }
3346
    }
3347
    *has_video_ptr = has_video;
3348
    *has_audio_ptr = has_audio;
3349
    *has_subtitle_ptr = has_subtitle;
3350
    *has_data_ptr = has_data;
3351
}
3352

    
3353
static void new_video_stream(AVFormatContext *oc, int file_idx)
3354
{
3355
    AVStream *st;
3356
    AVOutputStream *ost;
3357
    AVCodecContext *video_enc;
3358
    enum CodecID codec_id = CODEC_ID_NONE;
3359
    AVCodec *codec= NULL;
3360

    
3361
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3362
    if (!st) {
3363
        fprintf(stderr, "Could not alloc stream\n");
3364
        ffmpeg_exit(1);
3365
    }
3366
    ost = new_output_stream(oc, file_idx);
3367

    
3368
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3369
    if(!video_stream_copy){
3370
        if (video_codec_name) {
3371
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3372
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3373
            codec = avcodec_find_encoder_by_name(video_codec_name);
3374
            output_codecs[nb_output_codecs-1] = codec;
3375
        } else {
3376
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3377
            codec = avcodec_find_encoder(codec_id);
3378
        }
3379
    }
3380

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

    
3385
    st->codec->thread_count= thread_count;
3386

    
3387
    video_enc = st->codec;
3388

    
3389
    if(video_codec_tag)
3390
        video_enc->codec_tag= video_codec_tag;
3391

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

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

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

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

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

    
3426
        choose_pixel_fmt(st, codec);
3427

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

    
3436
        if(intra_matrix)
3437
            video_enc->intra_matrix = intra_matrix;
3438
        if(inter_matrix)
3439
            video_enc->inter_matrix = inter_matrix;
3440

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

    
3471
        if (do_psnr)
3472
            video_enc->flags|= CODEC_FLAG_PSNR;
3473

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

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

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

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

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

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

    
3527
    avcodec_get_context_defaults3(st->codec, codec);
3528

    
3529
    ost->bitstream_filters = audio_bitstream_filters;
3530
    audio_bitstream_filters= NULL;
3531

    
3532
    st->codec->thread_count= thread_count;
3533

    
3534
    audio_enc = st->codec;
3535
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3536

    
3537
    if(audio_codec_tag)
3538
        audio_enc->codec_tag= audio_codec_tag;
3539

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

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

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

    
3577
static void new_data_stream(AVFormatContext *oc, int file_idx)
3578
{
3579
    AVStream *st;
3580
    AVOutputStream *ost;
3581
    AVCodec *codec=NULL;
3582
    AVCodecContext *data_enc;
3583

    
3584
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3585
    if (!st) {
3586
        fprintf(stderr, "Could not alloc stream\n");
3587
        ffmpeg_exit(1);
3588
    }
3589
    ost = new_output_stream(oc, file_idx);
3590
    data_enc = st->codec;
3591
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3592
    if (!data_stream_copy) {
3593
        fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3594
        ffmpeg_exit(1);
3595
    }
3596
    avcodec_get_context_defaults3(st->codec, codec);
3597

    
3598
    data_enc->codec_type = AVMEDIA_TYPE_DATA;
3599

    
3600
    if (data_codec_tag)
3601
        data_enc->codec_tag= data_codec_tag;
3602

    
3603
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3604
        data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3605
        avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3606
    }
3607
    if (data_stream_copy) {
3608
        st->stream_copy = 1;
3609
    }
3610

    
3611
    data_disable = 0;
3612
    av_freep(&data_codec_name);
3613
    data_stream_copy = 0;
3614
}
3615

    
3616
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3617
{
3618
    AVStream *st;
3619
    AVOutputStream *ost;
3620
    AVCodec *codec=NULL;
3621
    AVCodecContext *subtitle_enc;
3622
    enum CodecID codec_id = CODEC_ID_NONE;
3623

    
3624
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3625
    if (!st) {
3626
        fprintf(stderr, "Could not alloc stream\n");
3627
        ffmpeg_exit(1);
3628
    }
3629
    ost = new_output_stream(oc, file_idx);
3630
    subtitle_enc = st->codec;
3631
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3632
    if(!subtitle_stream_copy){
3633
        if (subtitle_codec_name) {
3634
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3635
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3636
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3637
        } else {
3638
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3639
            codec = avcodec_find_encoder(codec_id);
3640
        }
3641
    }
3642
    avcodec_get_context_defaults3(st->codec, codec);
3643

    
3644
    ost->bitstream_filters = subtitle_bitstream_filters;
3645
    subtitle_bitstream_filters= NULL;
3646

    
3647
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3648

    
3649
    if(subtitle_codec_tag)
3650
        subtitle_enc->codec_tag= subtitle_codec_tag;
3651

    
3652
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3653
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3654
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3655
    }
3656
    if (subtitle_stream_copy) {
3657
        st->stream_copy = 1;
3658
    } else {
3659
        subtitle_enc->codec_id = codec_id;
3660
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3661
    }
3662

    
3663
    if (subtitle_language) {
3664
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3665
        av_freep(&subtitle_language);
3666
    }
3667

    
3668
    subtitle_disable = 0;
3669
    av_freep(&subtitle_codec_name);
3670
    subtitle_stream_copy = 0;
3671
}
3672

    
3673
static int opt_new_stream(const char *opt, const char *arg)
3674
{
3675
    AVFormatContext *oc;
3676
    int file_idx = nb_output_files - 1;
3677
    if (nb_output_files <= 0) {
3678
        fprintf(stderr, "At least one output file must be specified\n");
3679
        ffmpeg_exit(1);
3680
    }
3681
    oc = output_files[file_idx];
3682

    
3683
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3684
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3685
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3686
    else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3687
    else av_assert0(0);
3688
    return 0;
3689
}
3690

    
3691
/* arg format is "output-stream-index:streamid-value". */
3692
static int opt_streamid(const char *opt, const char *arg)
3693
{
3694
    int idx;
3695
    char *p;
3696
    char idx_str[16];
3697

    
3698
    av_strlcpy(idx_str, arg, sizeof(idx_str));
3699
    p = strchr(idx_str, ':');
3700
    if (!p) {
3701
        fprintf(stderr,
3702
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3703
                arg, opt);
3704
        ffmpeg_exit(1);
3705
    }
3706
    *p++ = '\0';
3707
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3708
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3709
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3710
    return 0;
3711
}
3712

    
3713
static void opt_output_file(const char *filename)
3714
{
3715
    AVFormatContext *oc;
3716
    int err, use_video, use_audio, use_subtitle, use_data;
3717
    int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3718
    AVFormatParameters params, *ap = &params;
3719
    AVOutputFormat *file_oformat;
3720

    
3721
    if (!strcmp(filename, "-"))
3722
        filename = "pipe:";
3723

    
3724
    oc = avformat_alloc_context();
3725
    if (!oc) {
3726
        print_error(filename, AVERROR(ENOMEM));
3727
        ffmpeg_exit(1);
3728
    }
3729

    
3730
    if (last_asked_format) {
3731
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3732
        if (!file_oformat) {
3733
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3734
            ffmpeg_exit(1);
3735
        }
3736
        last_asked_format = NULL;
3737
    } else {
3738
        file_oformat = av_guess_format(NULL, filename, NULL);
3739
        if (!file_oformat) {
3740
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3741
                    filename);
3742
            ffmpeg_exit(1);
3743
        }
3744
    }
3745

    
3746
    oc->oformat = file_oformat;
3747
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3748

    
3749
    if (!strcmp(file_oformat->name, "ffm") &&
3750
        av_strstart(filename, "http:", NULL)) {
3751
        /* special case for files sent to ffserver: we get the stream
3752
           parameters from ffserver */
3753
        int err = read_ffserver_streams(oc, filename);
3754
        if (err < 0) {
3755
            print_error(filename, err);
3756
            ffmpeg_exit(1);
3757
        }
3758
    } else {
3759
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3760
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3761
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3762
        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 */
3763

    
3764
        /* disable if no corresponding type found and at least one
3765
           input file */
3766
        if (nb_input_files > 0) {
3767
            check_inputs(&input_has_video,
3768
                         &input_has_audio,
3769
                         &input_has_subtitle,
3770
                         &input_has_data);
3771

    
3772
            if (!input_has_video)
3773
                use_video = 0;
3774
            if (!input_has_audio)
3775
                use_audio = 0;
3776
            if (!input_has_subtitle)
3777
                use_subtitle = 0;
3778
            if (!input_has_data)
3779
                use_data = 0;
3780
        }
3781

    
3782
        /* manual disable */
3783
        if (audio_disable)    use_audio    = 0;
3784
        if (video_disable)    use_video    = 0;
3785
        if (subtitle_disable) use_subtitle = 0;
3786
        if (data_disable)     use_data     = 0;
3787

    
3788
        if (use_video)    new_video_stream(oc, nb_output_files);
3789
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3790
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3791
        if (use_data)     new_data_stream(oc, nb_output_files);
3792

    
3793
        oc->timestamp = recording_timestamp;
3794

    
3795
        av_metadata_copy(&oc->metadata, metadata, 0);
3796
        av_metadata_free(&metadata);
3797
    }
3798

    
3799
    output_files[nb_output_files++] = oc;
3800

    
3801
    /* check filename in case of an image number is expected */
3802
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3803
        if (!av_filename_number_test(oc->filename)) {
3804
            print_error(oc->filename, AVERROR(EINVAL));
3805
            ffmpeg_exit(1);
3806
        }
3807
    }
3808

    
3809
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3810
        /* test if it already exists to avoid loosing precious files */
3811
        if (!file_overwrite &&
3812
            (strchr(filename, ':') == NULL ||
3813
             filename[1] == ':' ||
3814
             av_strstart(filename, "file:", NULL))) {
3815
            if (avio_check(filename, 0) == 0) {
3816
                if (!using_stdin) {
3817
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3818
                    fflush(stderr);
3819
                    if (!read_yesno()) {
3820
                        fprintf(stderr, "Not overwriting - exiting\n");
3821
                        ffmpeg_exit(1);
3822
                    }
3823
                }
3824
                else {
3825
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3826
                    ffmpeg_exit(1);
3827
                }
3828
            }
3829
        }
3830

    
3831
        /* open the file */
3832
        if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3833
            print_error(filename, err);
3834
            ffmpeg_exit(1);
3835
        }
3836
    }
3837

    
3838
    memset(ap, 0, sizeof(*ap));
3839
    if (av_set_parameters(oc, ap) < 0) {
3840
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3841
                oc->filename);
3842
        ffmpeg_exit(1);
3843
    }
3844

    
3845
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3846
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3847
    oc->loop_output = loop_output;
3848
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3849

    
3850
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3851

    
3852
    av_freep(&forced_key_frames);
3853
}
3854

    
3855
/* same option as mencoder */
3856
static void opt_pass(const char *pass_str)
3857
{
3858
    int pass;
3859
    pass = atoi(pass_str);
3860
    if (pass != 1 && pass != 2) {
3861
        fprintf(stderr, "pass number can be only 1 or 2\n");
3862
        ffmpeg_exit(1);
3863
    }
3864
    do_pass = pass;
3865
}
3866

    
3867
static int64_t getutime(void)
3868
{
3869
#if HAVE_GETRUSAGE
3870
    struct rusage rusage;
3871

    
3872
    getrusage(RUSAGE_SELF, &rusage);
3873
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3874
#elif HAVE_GETPROCESSTIMES
3875
    HANDLE proc;
3876
    FILETIME c, e, k, u;
3877
    proc = GetCurrentProcess();
3878
    GetProcessTimes(proc, &c, &e, &k, &u);
3879
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3880
#else
3881
    return av_gettime();
3882
#endif
3883
}
3884

    
3885
static int64_t getmaxrss(void)
3886
{
3887
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3888
    struct rusage rusage;
3889
    getrusage(RUSAGE_SELF, &rusage);
3890
    return (int64_t)rusage.ru_maxrss * 1024;
3891
#elif HAVE_GETPROCESSMEMORYINFO
3892
    HANDLE proc;
3893
    PROCESS_MEMORY_COUNTERS memcounters;
3894
    proc = GetCurrentProcess();
3895
    memcounters.cb = sizeof(memcounters);
3896
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3897
    return memcounters.PeakPagefileUsage;
3898
#else
3899
    return 0;
3900
#endif
3901
}
3902

    
3903
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3904
{
3905
    int i;
3906
    const char *p = str;
3907
    for(i = 0;; i++) {
3908
        dest[i] = atoi(p);
3909
        if(i == 63)
3910
            break;
3911
        p = strchr(p, ',');
3912
        if(!p) {
3913
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3914
            ffmpeg_exit(1);
3915
        }
3916
        p++;
3917
    }
3918
}
3919

    
3920
static void opt_inter_matrix(const char *arg)
3921
{
3922
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3923
    parse_matrix_coeffs(inter_matrix, arg);
3924
}
3925

    
3926
static void opt_intra_matrix(const char *arg)
3927
{
3928
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3929
    parse_matrix_coeffs(intra_matrix, arg);
3930
}
3931

    
3932
static void show_usage(void)
3933
{
3934
    printf("Hyper fast Audio and Video encoder\n");
3935
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3936
    printf("\n");
3937
}
3938

    
3939
static void show_help(void)
3940
{
3941
    AVCodec *c;
3942
    AVOutputFormat *oformat = NULL;
3943

    
3944
    av_log_set_callback(log_callback_help);
3945
    show_usage();
3946
    show_help_options(options, "Main options:\n",
3947
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3948
    show_help_options(options, "\nAdvanced options:\n",
3949
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3950
                      OPT_EXPERT);
3951
    show_help_options(options, "\nVideo options:\n",
3952
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3953
                      OPT_VIDEO);
3954
    show_help_options(options, "\nAdvanced Video options:\n",
3955
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3956
                      OPT_VIDEO | OPT_EXPERT);
3957
    show_help_options(options, "\nAudio options:\n",
3958
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3959
                      OPT_AUDIO);
3960
    show_help_options(options, "\nAdvanced Audio options:\n",
3961
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3962
                      OPT_AUDIO | OPT_EXPERT);
3963
    show_help_options(options, "\nSubtitle options:\n",
3964
                      OPT_SUBTITLE | OPT_GRAB,
3965
                      OPT_SUBTITLE);
3966
    show_help_options(options, "\nAudio/Video grab options:\n",
3967
                      OPT_GRAB,
3968
                      OPT_GRAB);
3969
    printf("\n");
3970
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3971
    printf("\n");
3972

    
3973
    /* individual codec options */
3974
    c = NULL;
3975
    while ((c = av_codec_next(c))) {
3976
        if (c->priv_class) {
3977
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3978
            printf("\n");
3979
        }
3980
    }
3981

    
3982
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3983
    printf("\n");
3984

    
3985
    /* individual muxer options */
3986
    while ((oformat = av_oformat_next(oformat))) {
3987
        if (oformat->priv_class) {
3988
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3989
            printf("\n");
3990
        }
3991
    }
3992

    
3993
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3994
}
3995

    
3996
static void opt_target(const char *arg)
3997
{
3998
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3999
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4000

    
4001
    if(!strncmp(arg, "pal-", 4)) {
4002
        norm = PAL;
4003
        arg += 4;
4004
    } else if(!strncmp(arg, "ntsc-", 5)) {
4005
        norm = NTSC;
4006
        arg += 5;
4007
    } else if(!strncmp(arg, "film-", 5)) {
4008
        norm = FILM;
4009
        arg += 5;
4010
    } else {
4011
        int fr;
4012
        /* Calculate FR via float to avoid int overflow */
4013
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4014
        if(fr == 25000) {
4015
            norm = PAL;
4016
        } else if((fr == 29970) || (fr == 23976)) {
4017
            norm = NTSC;
4018
        } else {
4019
            /* Try to determine PAL/NTSC by peeking in the input files */
4020
            if(nb_input_files) {
4021
                int i, j;
4022
                for(j = 0; j < nb_input_files; j++) {
4023
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
4024
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
4025
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4026
                            continue;
4027
                        fr = c->time_base.den * 1000 / c->time_base.num;
4028
                        if(fr == 25000) {
4029
                            norm = PAL;
4030
                            break;
4031
                        } else if((fr == 29970) || (fr == 23976)) {
4032
                            norm = NTSC;
4033
                            break;
4034
                        }
4035
                    }
4036
                    if(norm != UNKNOWN)
4037
                        break;
4038
                }
4039
            }
4040
        }
4041
        if(verbose && norm != UNKNOWN)
4042
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4043
    }
4044

    
4045
    if(norm == UNKNOWN) {
4046
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4047
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4048
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4049
        ffmpeg_exit(1);
4050
    }
4051

    
4052
    if(!strcmp(arg, "vcd")) {
4053

    
4054
        opt_video_codec("mpeg1video");
4055
        opt_audio_codec("mp2");
4056
        opt_format("vcd");
4057

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

    
4062
        opt_default("b", "1150000");
4063
        opt_default("maxrate", "1150000");
4064
        opt_default("minrate", "1150000");
4065
        opt_default("bufsize", "327680"); // 40*1024*8;
4066

    
4067
        opt_default("ab", "224000");
4068
        audio_sample_rate = 44100;
4069
        audio_channels = 2;
4070

    
4071
        opt_default("packetsize", "2324");
4072
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4073

    
4074
        /* We have to offset the PTS, so that it is consistent with the SCR.
4075
           SCR starts at 36000, but the first two packs contain only padding
4076
           and the first pack from the other stream, respectively, may also have
4077
           been written before.
4078
           So the real data starts at SCR 36000+3*1200. */
4079
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4080
    } else if(!strcmp(arg, "svcd")) {
4081

    
4082
        opt_video_codec("mpeg2video");
4083
        opt_audio_codec("mp2");
4084
        opt_format("svcd");
4085

    
4086
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4087
        opt_frame_rate(NULL, frame_rates[norm]);
4088
        opt_default("g", norm == PAL ? "15" : "18");
4089

    
4090
        opt_default("b", "2040000");
4091
        opt_default("maxrate", "2516000");
4092
        opt_default("minrate", "0"); //1145000;
4093
        opt_default("bufsize", "1835008"); //224*1024*8;
4094
        opt_default("flags", "+scan_offset");
4095

    
4096

    
4097
        opt_default("ab", "224000");
4098
        audio_sample_rate = 44100;
4099

    
4100
        opt_default("packetsize", "2324");
4101

    
4102
    } else if(!strcmp(arg, "dvd")) {
4103

    
4104
        opt_video_codec("mpeg2video");
4105
        opt_audio_codec("ac3");
4106
        opt_format("dvd");
4107

    
4108
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4109
        opt_frame_rate(NULL, frame_rates[norm]);
4110
        opt_default("g", norm == PAL ? "15" : "18");
4111

    
4112
        opt_default("b", "6000000");
4113
        opt_default("maxrate", "9000000");
4114
        opt_default("minrate", "0"); //1500000;
4115
        opt_default("bufsize", "1835008"); //224*1024*8;
4116

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

    
4120
        opt_default("ab", "448000");
4121
        audio_sample_rate = 48000;
4122

    
4123
    } else if(!strncmp(arg, "dv", 2)) {
4124

    
4125
        opt_format("dv");
4126

    
4127
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4128
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4129
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4130
        opt_frame_rate(NULL, frame_rates[norm]);
4131

    
4132
        audio_sample_rate = 48000;
4133
        audio_channels = 2;
4134

    
4135
    } else {
4136
        fprintf(stderr, "Unknown target: %s\n", arg);
4137
        ffmpeg_exit(1);
4138
    }
4139
}
4140

    
4141
static void opt_vstats_file (const char *arg)
4142
{
4143
    av_free (vstats_filename);
4144
    vstats_filename=av_strdup (arg);
4145
}
4146

    
4147
static void opt_vstats (void)
4148
{
4149
    char filename[40];
4150
    time_t today2 = time(NULL);
4151
    struct tm *today = localtime(&today2);
4152

    
4153
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4154
             today->tm_sec);
4155
    opt_vstats_file(filename);
4156
}
4157

    
4158
static int opt_bsf(const char *opt, const char *arg)
4159
{
4160
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4161
    AVBitStreamFilterContext **bsfp;
4162

    
4163
    if(!bsfc){
4164
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4165
        ffmpeg_exit(1);
4166
    }
4167

    
4168
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4169
          *opt == 'a' ? &audio_bitstream_filters :
4170
                        &subtitle_bitstream_filters;
4171
    while(*bsfp)
4172
        bsfp= &(*bsfp)->next;
4173

    
4174
    *bsfp= bsfc;
4175

    
4176
    return 0;
4177
}
4178

    
4179
static int opt_preset(const char *opt, const char *arg)
4180
{
4181
    FILE *f=NULL;
4182
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4183
    char *codec_name = *opt == 'v' ? video_codec_name :
4184
                       *opt == 'a' ? audio_codec_name :
4185
                                     subtitle_codec_name;
4186

    
4187
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4188
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4189
        ffmpeg_exit(1);
4190
    }
4191

    
4192
    while(!feof(f)){
4193
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4194
        if(line[0] == '#' && !e)
4195
            continue;
4196
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4197
        if(e){
4198
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4199
            ffmpeg_exit(1);
4200
        }
4201
        if(!strcmp(tmp, "acodec")){
4202
            opt_audio_codec(tmp2);
4203
        }else if(!strcmp(tmp, "vcodec")){
4204
            opt_video_codec(tmp2);
4205
        }else if(!strcmp(tmp, "scodec")){
4206
            opt_subtitle_codec(tmp2);
4207
        }else if(!strcmp(tmp, "dcodec")){
4208
            opt_data_codec(tmp2);
4209
        }else if(opt_default(tmp, tmp2) < 0){
4210
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4211
            ffmpeg_exit(1);
4212
        }
4213
    }
4214

    
4215
    fclose(f);
4216

    
4217
    return 0;
4218
}
4219

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

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

    
4313
    /* audio options */
4314
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4315
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4316
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4317
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4318
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4319
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4320
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4321
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4322
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4323
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4324
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4325
    { "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" },
4326

    
4327
    /* subtitle options */
4328
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4329
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4330
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4331
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4332
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4333

    
4334
    /* grab options */
4335
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4336
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4337
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4338

    
4339
    /* muxer options */
4340
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4341
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4342

    
4343
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4344
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4345
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4346

    
4347
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4348
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4349
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4350
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4351
    /* data codec support */
4352
    { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4353

    
4354
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4355
    { NULL, },
4356
};
4357

    
4358
int main(int argc, char **argv)
4359
{
4360
    int64_t ti;
4361

    
4362
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4363

    
4364
    avcodec_register_all();
4365
#if CONFIG_AVDEVICE
4366
    avdevice_register_all();
4367
#endif
4368
#if CONFIG_AVFILTER
4369
    avfilter_register_all();
4370
#endif
4371
    av_register_all();
4372

    
4373
#if HAVE_ISATTY
4374
    if(isatty(STDIN_FILENO))
4375
        avio_set_interrupt_cb(decode_interrupt_cb);
4376
#endif
4377

    
4378
    init_opts();
4379

    
4380
    show_banner();
4381

    
4382
    /* parse options */
4383
    parse_options(argc, argv, options, opt_output_file);
4384

    
4385
    if(nb_output_files <= 0 && nb_input_files == 0) {
4386
        show_usage();
4387
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4388
        ffmpeg_exit(1);
4389
    }
4390

    
4391
    /* file converter / grab */
4392
    if (nb_output_files <= 0) {
4393
        fprintf(stderr, "At least one output file must be specified\n");
4394
        ffmpeg_exit(1);
4395
    }
4396

    
4397
    if (nb_input_files == 0) {
4398
        fprintf(stderr, "At least one input file must be specified\n");
4399
        ffmpeg_exit(1);
4400
    }
4401

    
4402
    ti = getutime();
4403
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4404
                  stream_maps, nb_stream_maps) < 0)
4405
        ffmpeg_exit(1);
4406
    ti = getutime() - ti;
4407
    if (do_benchmark) {
4408
        int maxrss = getmaxrss() / 1024;
4409
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4410
    }
4411

    
4412
    return ffmpeg_exit(0);
4413
}