Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ d1991f51

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_video_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 > 0 || 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_video_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
#if CONFIG_AVFILTER
2807
    x = vfilters ? strlen(vfilters) : 0;
2808
    vfilters = av_realloc(vfilters, x+100);
2809
    snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2810
#endif
2811
}
2812

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

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

    
2823
    av_metadata_set2(&metadata, arg, mid, 0);
2824

    
2825
    return 0;
2826
}
2827

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

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

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

    
2853
static void opt_audio_sample_fmt(const char *arg)
2854
{
2855
    if (strcmp(arg, "list")) {
2856
        audio_sample_fmt = av_get_sample_fmt(arg);
2857
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2858
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2859
            ffmpeg_exit(1);
2860
        }
2861
    } else {
2862
        int i;
2863
        char fmt_str[128];
2864
        for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2865
            printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2866
        ffmpeg_exit(0);
2867
    }
2868
}
2869

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

    
2876
static int opt_audio_channels(const char *opt, const char *arg)
2877
{
2878
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2879
    return 0;
2880
}
2881

    
2882
static void opt_video_channel(const char *arg)
2883
{
2884
    video_channel = strtol(arg, NULL, 0);
2885
}
2886

    
2887
static void opt_video_standard(const char *arg)
2888
{
2889
    video_standard = av_strdup(arg);
2890
}
2891

    
2892
static void opt_codec(int *pstream_copy, char **pcodec_name,
2893
                      int codec_type, const char *arg)
2894
{
2895
    av_freep(pcodec_name);
2896
    if (!strcmp(arg, "copy")) {
2897
        *pstream_copy = 1;
2898
    } else {
2899
        *pcodec_name = av_strdup(arg);
2900
    }
2901
}
2902

    
2903
static void opt_audio_codec(const char *arg)
2904
{
2905
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2906
}
2907

    
2908
static void opt_video_codec(const char *arg)
2909
{
2910
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2911
}
2912

    
2913
static void opt_subtitle_codec(const char *arg)
2914
{
2915
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2916
}
2917

    
2918
static void opt_data_codec(const char *arg)
2919
{
2920
    opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2921
}
2922

    
2923
static int opt_codec_tag(const char *opt, const char *arg)
2924
{
2925
    char *tail;
2926
    uint32_t *codec_tag;
2927

    
2928
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2929
                !strcmp(opt, "vtag") ? &video_codec_tag :
2930
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2931
    if (!codec_tag)
2932
        return -1;
2933

    
2934
    *codec_tag = strtol(arg, &tail, 0);
2935
    if (!tail || *tail)
2936
        *codec_tag = AV_RL32(arg);
2937

    
2938
    return 0;
2939
}
2940

    
2941
static void opt_map(const char *arg)
2942
{
2943
    AVStreamMap *m;
2944
    char *p;
2945

    
2946
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2947
    m = &stream_maps[nb_stream_maps-1];
2948

    
2949
    m->file_index = strtol(arg, &p, 0);
2950
    if (*p)
2951
        p++;
2952

    
2953
    m->stream_index = strtol(p, &p, 0);
2954
    if (*p) {
2955
        p++;
2956
        m->sync_file_index = strtol(p, &p, 0);
2957
        if (*p)
2958
            p++;
2959
        m->sync_stream_index = strtol(p, &p, 0);
2960
    } else {
2961
        m->sync_file_index = m->file_index;
2962
        m->sync_stream_index = m->stream_index;
2963
    }
2964
}
2965

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

    
2987
static void opt_map_metadata(const char *arg)
2988
{
2989
    AVMetaDataMap *m, *m1;
2990
    char *p;
2991

    
2992
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2993
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2994

    
2995
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
2996
    m->file = strtol(arg, &p, 0);
2997
    parse_meta_type(p, &m->type, &m->index, &p);
2998
    if (*p)
2999
        p++;
3000

    
3001
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3002
    m1->file = strtol(p, &p, 0);
3003
    parse_meta_type(p, &m1->type, &m1->index, &p);
3004

    
3005
    if (m->type == 'g' || m1->type == 'g')
3006
        metadata_global_autocopy = 0;
3007
    if (m->type == 's' || m1->type == 's')
3008
        metadata_streams_autocopy = 0;
3009
    if (m->type == 'c' || m1->type == 'c')
3010
        metadata_chapters_autocopy = 0;
3011
}
3012

    
3013
static void opt_map_meta_data(const char *arg)
3014
{
3015
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3016
                    "Use -map_metadata instead.\n");
3017
    opt_map_metadata(arg);
3018
}
3019

    
3020
static void opt_map_chapters(const char *arg)
3021
{
3022
    AVChapterMap *c;
3023
    char *p;
3024

    
3025
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3026
                              nb_chapter_maps + 1);
3027
    c = &chapter_maps[nb_chapter_maps - 1];
3028
    c->out_file = strtol(arg, &p, 0);
3029
    if (*p)
3030
        p++;
3031

    
3032
    c->in_file = strtol(p, &p, 0);
3033
}
3034

    
3035
static void opt_input_ts_scale(const char *arg)
3036
{
3037
    unsigned int stream;
3038
    double scale;
3039
    char *p;
3040

    
3041
    stream = strtol(arg, &p, 0);
3042
    if (*p)
3043
        p++;
3044
    scale= strtod(p, &p);
3045

    
3046
    if(stream >= MAX_STREAMS)
3047
        ffmpeg_exit(1);
3048

    
3049
    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);
3050
    input_files_ts_scale[nb_input_files][stream]= scale;
3051
}
3052

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

    
3059
static int opt_start_time(const char *opt, const char *arg)
3060
{
3061
    start_time = parse_time_or_die(opt, arg, 1);
3062
    return 0;
3063
}
3064

    
3065
static int opt_recording_timestamp(const char *opt, const char *arg)
3066
{
3067
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3068
    return 0;
3069
}
3070

    
3071
static int opt_input_ts_offset(const char *opt, const char *arg)
3072
{
3073
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3074
    return 0;
3075
}
3076

    
3077
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3078
{
3079
    const char *codec_string = encoder ? "encoder" : "decoder";
3080
    AVCodec *codec;
3081

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

    
3111
static void opt_input_file(const char *filename)
3112
{
3113
    AVFormatContext *ic;
3114
    AVFormatParameters params, *ap = &params;
3115
    AVInputFormat *file_iformat = NULL;
3116
    int err, i, ret, rfps, rfps_base;
3117
    int64_t timestamp;
3118

    
3119
    if (last_asked_format) {
3120
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3121
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3122
            ffmpeg_exit(1);
3123
        }
3124
        last_asked_format = NULL;
3125
    }
3126

    
3127
    if (!strcmp(filename, "-"))
3128
        filename = "pipe:";
3129

    
3130
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3131
                    !strcmp(filename, "/dev/stdin");
3132

    
3133
    /* get default parameters from command line */
3134
    ic = avformat_alloc_context();
3135
    if (!ic) {
3136
        print_error(filename, AVERROR(ENOMEM));
3137
        ffmpeg_exit(1);
3138
    }
3139

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

    
3153
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3154

    
3155
    ic->video_codec_id   =
3156
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3157
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3158
    ic->audio_codec_id   =
3159
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3160
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3161
    ic->subtitle_codec_id=
3162
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3163
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3164
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3165

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

    
3196
    ic->loop_input = loop_input;
3197

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

    
3207
    timestamp = start_time;
3208
    /* add the stream start time */
3209
    if (ic->start_time != AV_NOPTS_VALUE)
3210
        timestamp += ic->start_time;
3211

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

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

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

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

    
3274
                    (float)rfps / rfps_base, rfps, rfps_base);
3275
            }
3276
            /* update the current frame rate to match the stream frame rate */
3277
            frame_rate.num = rfps;
3278
            frame_rate.den = rfps_base;
3279

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

    
3300
    input_files[nb_input_files] = ic;
3301
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3302
    /* dump the file content */
3303
    if (verbose >= 0)
3304
        av_dump_format(ic, nb_input_files, filename, 0);
3305

    
3306
    nb_input_files++;
3307

    
3308
    video_channel = 0;
3309

    
3310
    av_freep(&video_codec_name);
3311
    av_freep(&audio_codec_name);
3312
    av_freep(&subtitle_codec_name);
3313
    uninit_opts();
3314
    init_opts();
3315
}
3316

    
3317
static void check_inputs(int *has_video_ptr,
3318
                         int *has_audio_ptr,
3319
                         int *has_subtitle_ptr,
3320
                         int *has_data_ptr)
3321
{
3322
    int has_video, has_audio, has_subtitle, has_data, i, j;
3323
    AVFormatContext *ic;
3324

    
3325
    has_video = 0;
3326
    has_audio = 0;
3327
    has_subtitle = 0;
3328
    has_data = 0;
3329

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

    
3360
static void new_video_stream(AVFormatContext *oc, int file_idx)
3361
{
3362
    AVStream *st;
3363
    AVOutputStream *ost;
3364
    AVCodecContext *video_enc;
3365
    enum CodecID codec_id = CODEC_ID_NONE;
3366
    AVCodec *codec= NULL;
3367

    
3368
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3369
    if (!st) {
3370
        fprintf(stderr, "Could not alloc stream\n");
3371
        ffmpeg_exit(1);
3372
    }
3373
    ost = new_output_stream(oc, file_idx);
3374

    
3375
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3376
    if(!video_stream_copy){
3377
        if (video_codec_name) {
3378
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3379
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3380
            codec = avcodec_find_encoder_by_name(video_codec_name);
3381
            output_codecs[nb_output_codecs-1] = codec;
3382
        } else {
3383
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3384
            codec = avcodec_find_encoder(codec_id);
3385
        }
3386
    }
3387

    
3388
    avcodec_get_context_defaults3(st->codec, codec);
3389
    ost->bitstream_filters = video_bitstream_filters;
3390
    video_bitstream_filters= NULL;
3391

    
3392
    st->codec->thread_count= thread_count;
3393

    
3394
    video_enc = st->codec;
3395

    
3396
    if(video_codec_tag)
3397
        video_enc->codec_tag= video_codec_tag;
3398

    
3399
    if(   (video_global_header&1)
3400
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3401
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3402
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3403
    }
3404
    if(video_global_header&2){
3405
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3406
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3407
    }
3408

    
3409
    if (video_stream_copy) {
3410
        st->stream_copy = 1;
3411
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3412
        video_enc->sample_aspect_ratio =
3413
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3414
    } else {
3415
        const char *p;
3416
        int i;
3417
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3418

    
3419
        video_enc->codec_id = codec_id;
3420
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3421

    
3422
        if (codec && codec->supported_framerates && !force_fps)
3423
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3424
        video_enc->time_base.den = fps.num;
3425
        video_enc->time_base.num = fps.den;
3426

    
3427
        video_enc->width = frame_width;
3428
        video_enc->height = frame_height;
3429
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3430
        video_enc->pix_fmt = frame_pix_fmt;
3431
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3432

    
3433
        choose_pixel_fmt(st, codec);
3434

    
3435
        if (intra_only)
3436
            video_enc->gop_size = 0;
3437
        if (video_qscale || same_quality) {
3438
            video_enc->flags |= CODEC_FLAG_QSCALE;
3439
            video_enc->global_quality=
3440
                st->quality = FF_QP2LAMBDA * video_qscale;
3441
        }
3442

    
3443
        if(intra_matrix)
3444
            video_enc->intra_matrix = intra_matrix;
3445
        if(inter_matrix)
3446
            video_enc->inter_matrix = inter_matrix;
3447

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

    
3478
        if (do_psnr)
3479
            video_enc->flags|= CODEC_FLAG_PSNR;
3480

    
3481
        /* two pass mode */
3482
        if (do_pass) {
3483
            if (do_pass == 1) {
3484
                video_enc->flags |= CODEC_FLAG_PASS1;
3485
            } else {
3486
                video_enc->flags |= CODEC_FLAG_PASS2;
3487
            }
3488
        }
3489

    
3490
        if (forced_key_frames)
3491
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3492
    }
3493
    if (video_language) {
3494
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3495
        av_freep(&video_language);
3496
    }
3497

    
3498
    /* reset some key parameters */
3499
    video_disable = 0;
3500
    av_freep(&video_codec_name);
3501
    av_freep(&forced_key_frames);
3502
    video_stream_copy = 0;
3503
    frame_pix_fmt = PIX_FMT_NONE;
3504
}
3505

    
3506
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3507
{
3508
    AVStream *st;
3509
    AVOutputStream *ost;
3510
    AVCodec *codec= NULL;
3511
    AVCodecContext *audio_enc;
3512
    enum CodecID codec_id = CODEC_ID_NONE;
3513

    
3514
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3515
    if (!st) {
3516
        fprintf(stderr, "Could not alloc stream\n");
3517
        ffmpeg_exit(1);
3518
    }
3519
    ost = new_output_stream(oc, file_idx);
3520

    
3521
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3522
    if(!audio_stream_copy){
3523
        if (audio_codec_name) {
3524
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3525
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3526
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3527
            output_codecs[nb_output_codecs-1] = codec;
3528
        } else {
3529
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3530
            codec = avcodec_find_encoder(codec_id);
3531
        }
3532
    }
3533

    
3534
    avcodec_get_context_defaults3(st->codec, codec);
3535

    
3536
    ost->bitstream_filters = audio_bitstream_filters;
3537
    audio_bitstream_filters= NULL;
3538

    
3539
    st->codec->thread_count= thread_count;
3540

    
3541
    audio_enc = st->codec;
3542
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3543

    
3544
    if(audio_codec_tag)
3545
        audio_enc->codec_tag= audio_codec_tag;
3546

    
3547
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3548
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3549
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3550
    }
3551
    if (audio_stream_copy) {
3552
        st->stream_copy = 1;
3553
        audio_enc->channels = audio_channels;
3554
        audio_enc->sample_rate = audio_sample_rate;
3555
    } else {
3556
        audio_enc->codec_id = codec_id;
3557
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3558

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

    
3578
    /* reset some key parameters */
3579
    audio_disable = 0;
3580
    av_freep(&audio_codec_name);
3581
    audio_stream_copy = 0;
3582
}
3583

    
3584
static void new_data_stream(AVFormatContext *oc, int file_idx)
3585
{
3586
    AVStream *st;
3587
    AVOutputStream *ost;
3588
    AVCodec *codec=NULL;
3589
    AVCodecContext *data_enc;
3590

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

    
3605
    data_enc->codec_type = AVMEDIA_TYPE_DATA;
3606

    
3607
    if (data_codec_tag)
3608
        data_enc->codec_tag= data_codec_tag;
3609

    
3610
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3611
        data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3612
        avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3613
    }
3614
    if (data_stream_copy) {
3615
        st->stream_copy = 1;
3616
    }
3617

    
3618
    data_disable = 0;
3619
    av_freep(&data_codec_name);
3620
    data_stream_copy = 0;
3621
}
3622

    
3623
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3624
{
3625
    AVStream *st;
3626
    AVOutputStream *ost;
3627
    AVCodec *codec=NULL;
3628
    AVCodecContext *subtitle_enc;
3629
    enum CodecID codec_id = CODEC_ID_NONE;
3630

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

    
3651
    ost->bitstream_filters = subtitle_bitstream_filters;
3652
    subtitle_bitstream_filters= NULL;
3653

    
3654
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3655

    
3656
    if(subtitle_codec_tag)
3657
        subtitle_enc->codec_tag= subtitle_codec_tag;
3658

    
3659
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3660
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3661
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3662
    }
3663
    if (subtitle_stream_copy) {
3664
        st->stream_copy = 1;
3665
    } else {
3666
        subtitle_enc->codec_id = codec_id;
3667
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3668
    }
3669

    
3670
    if (subtitle_language) {
3671
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3672
        av_freep(&subtitle_language);
3673
    }
3674

    
3675
    subtitle_disable = 0;
3676
    av_freep(&subtitle_codec_name);
3677
    subtitle_stream_copy = 0;
3678
}
3679

    
3680
static int opt_new_stream(const char *opt, const char *arg)
3681
{
3682
    AVFormatContext *oc;
3683
    int file_idx = nb_output_files - 1;
3684
    if (nb_output_files <= 0) {
3685
        fprintf(stderr, "At least one output file must be specified\n");
3686
        ffmpeg_exit(1);
3687
    }
3688
    oc = output_files[file_idx];
3689

    
3690
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3691
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3692
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3693
    else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3694
    else av_assert0(0);
3695
    return 0;
3696
}
3697

    
3698
/* arg format is "output-stream-index:streamid-value". */
3699
static int opt_streamid(const char *opt, const char *arg)
3700
{
3701
    int idx;
3702
    char *p;
3703
    char idx_str[16];
3704

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

    
3720
static void opt_output_file(const char *filename)
3721
{
3722
    AVFormatContext *oc;
3723
    int err, use_video, use_audio, use_subtitle, use_data;
3724
    int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3725
    AVFormatParameters params, *ap = &params;
3726
    AVOutputFormat *file_oformat;
3727

    
3728
    if (!strcmp(filename, "-"))
3729
        filename = "pipe:";
3730

    
3731
    oc = avformat_alloc_context();
3732
    if (!oc) {
3733
        print_error(filename, AVERROR(ENOMEM));
3734
        ffmpeg_exit(1);
3735
    }
3736

    
3737
    if (last_asked_format) {
3738
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3739
        if (!file_oformat) {
3740
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3741
            ffmpeg_exit(1);
3742
        }
3743
        last_asked_format = NULL;
3744
    } else {
3745
        file_oformat = av_guess_format(NULL, filename, NULL);
3746
        if (!file_oformat) {
3747
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3748
                    filename);
3749
            ffmpeg_exit(1);
3750
        }
3751
    }
3752

    
3753
    oc->oformat = file_oformat;
3754
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3755

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

    
3771
        /* disable if no corresponding type found and at least one
3772
           input file */
3773
        if (nb_input_files > 0) {
3774
            check_inputs(&input_has_video,
3775
                         &input_has_audio,
3776
                         &input_has_subtitle,
3777
                         &input_has_data);
3778

    
3779
            if (!input_has_video)
3780
                use_video = 0;
3781
            if (!input_has_audio)
3782
                use_audio = 0;
3783
            if (!input_has_subtitle)
3784
                use_subtitle = 0;
3785
            if (!input_has_data)
3786
                use_data = 0;
3787
        }
3788

    
3789
        /* manual disable */
3790
        if (audio_disable)    use_audio    = 0;
3791
        if (video_disable)    use_video    = 0;
3792
        if (subtitle_disable) use_subtitle = 0;
3793
        if (data_disable)     use_data     = 0;
3794

    
3795
        if (use_video)    new_video_stream(oc, nb_output_files);
3796
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3797
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3798
        if (use_data)     new_data_stream(oc, nb_output_files);
3799

    
3800
        oc->timestamp = recording_timestamp;
3801

    
3802
        av_metadata_copy(&oc->metadata, metadata, 0);
3803
        av_metadata_free(&metadata);
3804
    }
3805

    
3806
    output_files[nb_output_files++] = oc;
3807

    
3808
    /* check filename in case of an image number is expected */
3809
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3810
        if (!av_filename_number_test(oc->filename)) {
3811
            print_error(oc->filename, AVERROR(EINVAL));
3812
            ffmpeg_exit(1);
3813
        }
3814
    }
3815

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

    
3838
        /* open the file */
3839
        if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3840
            print_error(filename, err);
3841
            ffmpeg_exit(1);
3842
        }
3843
    }
3844

    
3845
    memset(ap, 0, sizeof(*ap));
3846
    if (av_set_parameters(oc, ap) < 0) {
3847
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3848
                oc->filename);
3849
        ffmpeg_exit(1);
3850
    }
3851

    
3852
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3853
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3854
    oc->loop_output = loop_output;
3855
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3856

    
3857
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3858

    
3859
    av_freep(&forced_key_frames);
3860
    uninit_opts();
3861
    init_opts();
3862
}
3863

    
3864
/* same option as mencoder */
3865
static void opt_pass(const char *pass_str)
3866
{
3867
    int pass;
3868
    pass = atoi(pass_str);
3869
    if (pass != 1 && pass != 2) {
3870
        fprintf(stderr, "pass number can be only 1 or 2\n");
3871
        ffmpeg_exit(1);
3872
    }
3873
    do_pass = pass;
3874
}
3875

    
3876
static int64_t getutime(void)
3877
{
3878
#if HAVE_GETRUSAGE
3879
    struct rusage rusage;
3880

    
3881
    getrusage(RUSAGE_SELF, &rusage);
3882
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3883
#elif HAVE_GETPROCESSTIMES
3884
    HANDLE proc;
3885
    FILETIME c, e, k, u;
3886
    proc = GetCurrentProcess();
3887
    GetProcessTimes(proc, &c, &e, &k, &u);
3888
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3889
#else
3890
    return av_gettime();
3891
#endif
3892
}
3893

    
3894
static int64_t getmaxrss(void)
3895
{
3896
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3897
    struct rusage rusage;
3898
    getrusage(RUSAGE_SELF, &rusage);
3899
    return (int64_t)rusage.ru_maxrss * 1024;
3900
#elif HAVE_GETPROCESSMEMORYINFO
3901
    HANDLE proc;
3902
    PROCESS_MEMORY_COUNTERS memcounters;
3903
    proc = GetCurrentProcess();
3904
    memcounters.cb = sizeof(memcounters);
3905
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3906
    return memcounters.PeakPagefileUsage;
3907
#else
3908
    return 0;
3909
#endif
3910
}
3911

    
3912
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3913
{
3914
    int i;
3915
    const char *p = str;
3916
    for(i = 0;; i++) {
3917
        dest[i] = atoi(p);
3918
        if(i == 63)
3919
            break;
3920
        p = strchr(p, ',');
3921
        if(!p) {
3922
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3923
            ffmpeg_exit(1);
3924
        }
3925
        p++;
3926
    }
3927
}
3928

    
3929
static void opt_inter_matrix(const char *arg)
3930
{
3931
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3932
    parse_matrix_coeffs(inter_matrix, arg);
3933
}
3934

    
3935
static void opt_intra_matrix(const char *arg)
3936
{
3937
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3938
    parse_matrix_coeffs(intra_matrix, arg);
3939
}
3940

    
3941
static void show_usage(void)
3942
{
3943
    printf("Hyper fast Audio and Video encoder\n");
3944
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3945
    printf("\n");
3946
}
3947

    
3948
static void show_help(void)
3949
{
3950
    AVCodec *c;
3951
    AVOutputFormat *oformat = NULL;
3952

    
3953
    av_log_set_callback(log_callback_help);
3954
    show_usage();
3955
    show_help_options(options, "Main options:\n",
3956
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3957
    show_help_options(options, "\nAdvanced options:\n",
3958
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3959
                      OPT_EXPERT);
3960
    show_help_options(options, "\nVideo options:\n",
3961
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3962
                      OPT_VIDEO);
3963
    show_help_options(options, "\nAdvanced Video options:\n",
3964
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3965
                      OPT_VIDEO | OPT_EXPERT);
3966
    show_help_options(options, "\nAudio options:\n",
3967
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3968
                      OPT_AUDIO);
3969
    show_help_options(options, "\nAdvanced Audio options:\n",
3970
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3971
                      OPT_AUDIO | OPT_EXPERT);
3972
    show_help_options(options, "\nSubtitle options:\n",
3973
                      OPT_SUBTITLE | OPT_GRAB,
3974
                      OPT_SUBTITLE);
3975
    show_help_options(options, "\nAudio/Video grab options:\n",
3976
                      OPT_GRAB,
3977
                      OPT_GRAB);
3978
    printf("\n");
3979
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3980
    printf("\n");
3981

    
3982
    /* individual codec options */
3983
    c = NULL;
3984
    while ((c = av_codec_next(c))) {
3985
        if (c->priv_class) {
3986
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3987
            printf("\n");
3988
        }
3989
    }
3990

    
3991
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3992
    printf("\n");
3993

    
3994
    /* individual muxer options */
3995
    while ((oformat = av_oformat_next(oformat))) {
3996
        if (oformat->priv_class) {
3997
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3998
            printf("\n");
3999
        }
4000
    }
4001

    
4002
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4003
}
4004

    
4005
static void opt_target(const char *arg)
4006
{
4007
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4008
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4009

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

    
4054
    if(norm == UNKNOWN) {
4055
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4056
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4057
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4058
        ffmpeg_exit(1);
4059
    }
4060

    
4061
    if(!strcmp(arg, "vcd")) {
4062

    
4063
        opt_video_codec("mpeg1video");
4064
        opt_audio_codec("mp2");
4065
        opt_format("vcd");
4066

    
4067
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4068
        opt_frame_rate(NULL, frame_rates[norm]);
4069
        opt_default("g", norm == PAL ? "15" : "18");
4070

    
4071
        opt_default("b", "1150000");
4072
        opt_default("maxrate", "1150000");
4073
        opt_default("minrate", "1150000");
4074
        opt_default("bufsize", "327680"); // 40*1024*8;
4075

    
4076
        opt_default("ab", "224000");
4077
        audio_sample_rate = 44100;
4078
        audio_channels = 2;
4079

    
4080
        opt_default("packetsize", "2324");
4081
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4082

    
4083
        /* We have to offset the PTS, so that it is consistent with the SCR.
4084
           SCR starts at 36000, but the first two packs contain only padding
4085
           and the first pack from the other stream, respectively, may also have
4086
           been written before.
4087
           So the real data starts at SCR 36000+3*1200. */
4088
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4089
    } else if(!strcmp(arg, "svcd")) {
4090

    
4091
        opt_video_codec("mpeg2video");
4092
        opt_audio_codec("mp2");
4093
        opt_format("svcd");
4094

    
4095
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4096
        opt_frame_rate(NULL, frame_rates[norm]);
4097
        opt_default("g", norm == PAL ? "15" : "18");
4098

    
4099
        opt_default("b", "2040000");
4100
        opt_default("maxrate", "2516000");
4101
        opt_default("minrate", "0"); //1145000;
4102
        opt_default("bufsize", "1835008"); //224*1024*8;
4103
        opt_default("flags", "+scan_offset");
4104

    
4105

    
4106
        opt_default("ab", "224000");
4107
        audio_sample_rate = 44100;
4108

    
4109
        opt_default("packetsize", "2324");
4110

    
4111
    } else if(!strcmp(arg, "dvd")) {
4112

    
4113
        opt_video_codec("mpeg2video");
4114
        opt_audio_codec("ac3");
4115
        opt_format("dvd");
4116

    
4117
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4118
        opt_frame_rate(NULL, frame_rates[norm]);
4119
        opt_default("g", norm == PAL ? "15" : "18");
4120

    
4121
        opt_default("b", "6000000");
4122
        opt_default("maxrate", "9000000");
4123
        opt_default("minrate", "0"); //1500000;
4124
        opt_default("bufsize", "1835008"); //224*1024*8;
4125

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

    
4129
        opt_default("ab", "448000");
4130
        audio_sample_rate = 48000;
4131

    
4132
    } else if(!strncmp(arg, "dv", 2)) {
4133

    
4134
        opt_format("dv");
4135

    
4136
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4137
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4138
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4139
        opt_frame_rate(NULL, frame_rates[norm]);
4140

    
4141
        audio_sample_rate = 48000;
4142
        audio_channels = 2;
4143

    
4144
    } else {
4145
        fprintf(stderr, "Unknown target: %s\n", arg);
4146
        ffmpeg_exit(1);
4147
    }
4148
}
4149

    
4150
static void opt_vstats_file (const char *arg)
4151
{
4152
    av_free (vstats_filename);
4153
    vstats_filename=av_strdup (arg);
4154
}
4155

    
4156
static void opt_vstats (void)
4157
{
4158
    char filename[40];
4159
    time_t today2 = time(NULL);
4160
    struct tm *today = localtime(&today2);
4161

    
4162
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4163
             today->tm_sec);
4164
    opt_vstats_file(filename);
4165
}
4166

    
4167
static int opt_bsf(const char *opt, const char *arg)
4168
{
4169
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4170
    AVBitStreamFilterContext **bsfp;
4171

    
4172
    if(!bsfc){
4173
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4174
        ffmpeg_exit(1);
4175
    }
4176

    
4177
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4178
          *opt == 'a' ? &audio_bitstream_filters :
4179
                        &subtitle_bitstream_filters;
4180
    while(*bsfp)
4181
        bsfp= &(*bsfp)->next;
4182

    
4183
    *bsfp= bsfc;
4184

    
4185
    return 0;
4186
}
4187

    
4188
static int opt_preset(const char *opt, const char *arg)
4189
{
4190
    FILE *f=NULL;
4191
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4192
    char *codec_name = *opt == 'v' ? video_codec_name :
4193
                       *opt == 'a' ? audio_codec_name :
4194
                                     subtitle_codec_name;
4195

    
4196
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4197
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4198
        ffmpeg_exit(1);
4199
    }
4200

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

    
4224
    fclose(f);
4225

    
4226
    return 0;
4227
}
4228

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

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

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

    
4336
    /* subtitle options */
4337
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4338
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4339
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4340
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4341
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4342

    
4343
    /* grab options */
4344
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4345
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4346
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4347

    
4348
    /* muxer options */
4349
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4350
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4351

    
4352
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4353
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4354
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4355

    
4356
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4357
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4358
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4359
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4360
    /* data codec support */
4361
    { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4362

    
4363
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4364
    { NULL, },
4365
};
4366

    
4367
int main(int argc, char **argv)
4368
{
4369
    int64_t ti;
4370

    
4371
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4372

    
4373
    avcodec_register_all();
4374
#if CONFIG_AVDEVICE
4375
    avdevice_register_all();
4376
#endif
4377
#if CONFIG_AVFILTER
4378
    avfilter_register_all();
4379
#endif
4380
    av_register_all();
4381

    
4382
#if HAVE_ISATTY
4383
    if(isatty(STDIN_FILENO))
4384
        avio_set_interrupt_cb(decode_interrupt_cb);
4385
#endif
4386

    
4387
    init_opts();
4388

    
4389
    show_banner();
4390

    
4391
    /* parse options */
4392
    parse_options(argc, argv, options, opt_output_file);
4393

    
4394
    if(nb_output_files <= 0 && nb_input_files == 0) {
4395
        show_usage();
4396
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4397
        ffmpeg_exit(1);
4398
    }
4399

    
4400
    /* file converter / grab */
4401
    if (nb_output_files <= 0) {
4402
        fprintf(stderr, "At least one output file must be specified\n");
4403
        ffmpeg_exit(1);
4404
    }
4405

    
4406
    if (nb_input_files == 0) {
4407
        fprintf(stderr, "At least one input file must be specified\n");
4408
        ffmpeg_exit(1);
4409
    }
4410

    
4411
    ti = getutime();
4412
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4413
                  stream_maps, nb_stream_maps) < 0)
4414
        ffmpeg_exit(1);
4415
    ti = getutime() - ti;
4416
    if (do_benchmark) {
4417
        int maxrss = getmaxrss() / 1024;
4418
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4419
    }
4420

    
4421
    return ffmpeg_exit(0);
4422
}