Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ bebe72f4

History | View | Annotate | Download (159 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 float mux_preload= 0.5;
190
static float mux_max_delay= 0.7;
191

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

    
219
static int rate_emu = 0;
220

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

    
224
static int audio_volume = 256;
225

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

    
241
static float dts_delta_threshold = 10;
242

    
243
static unsigned int sws_flags = SWS_BICUBIC;
244

    
245
static int64_t timer_start;
246

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

    
251
static short *samples;
252

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

    
257
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
258

    
259
struct AVInputStream;
260

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

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

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

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

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

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

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

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

    
338
#if CONFIG_AVFILTER
339

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

    
351
    graph = avfilter_graph_alloc();
352

    
353
    if (ist->st->sample_aspect_ratio.num){
354
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
355
    }else
356
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
357

    
358
    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
359
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
360
             sample_aspect_ratio.num, sample_aspect_ratio.den);
361

    
362
    ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
363
                                       "src", args, NULL, graph);
364
    if (ret < 0)
365
        return ret;
366
    ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
367
                                       "out", NULL, &ffsink_ctx, graph);
368
    if (ret < 0)
369
        return ret;
370
    last_filter = ist->input_video_filter;
371

    
372
    if (codec->width  != icodec->width || codec->height != icodec->height) {
373
        snprintf(args, 255, "%d:%d:flags=0x%X",
374
                 codec->width,
375
                 codec->height,
376
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
377
        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
378
                                                NULL, args, NULL, graph)) < 0)
379
            return ret;
380
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
381
            return ret;
382
        last_filter = filter;
383
    }
384

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

    
388
    if (vfilters) {
389
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
390
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
391

    
392
        outputs->name    = av_strdup("in");
393
        outputs->filter_ctx = last_filter;
394
        outputs->pad_idx = 0;
395
        outputs->next    = NULL;
396

    
397
        inputs->name    = av_strdup("out");
398
        inputs->filter_ctx = ist->output_video_filter;
399
        inputs->pad_idx = 0;
400
        inputs->next    = NULL;
401

    
402
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
403
            return ret;
404
        av_freep(&vfilters);
405
    } else {
406
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
407
            return ret;
408
    }
409

    
410
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
411
        return ret;
412

    
413
    codec->width  = ist->output_video_filter->inputs[0]->w;
414
    codec->height = ist->output_video_filter->inputs[0]->h;
415
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
416
        ist->output_video_filter->inputs[0]->sample_aspect_ratio;
417

    
418
    return 0;
419
}
420
#endif /* CONFIG_AVFILTER */
421

    
422
static void term_exit(void)
423
{
424
    av_log(NULL, AV_LOG_QUIET, "");
425
}
426

    
427
static volatile int received_sigterm = 0;
428

    
429
static void
430
sigterm_handler(int sig)
431
{
432
    received_sigterm = sig;
433
    term_exit();
434
}
435

    
436
static void term_init(void)
437
{
438
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
439
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
440
#ifdef SIGXCPU
441
    signal(SIGXCPU, sigterm_handler);
442
#endif
443
}
444

    
445
/* read a key without blocking */
446
static int read_key(void)
447
{
448
#if HAVE_KBHIT
449
    if(kbhit())
450
        return(getch());
451
#endif
452
    return -1;
453
}
454

    
455
static int decode_interrupt_cb(void)
456
{
457
    return q_pressed || (q_pressed = read_key() == 'q');
458
}
459

    
460
static int ffmpeg_exit(int ret)
461
{
462
    int i;
463

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

    
477
    av_free(intra_matrix);
478
    av_free(inter_matrix);
479

    
480
    if (vstats_file)
481
        fclose(vstats_file);
482
    av_free(vstats_filename);
483

    
484
    av_free(streamid_map);
485
    av_free(input_codecs);
486
    av_free(output_codecs);
487
    av_free(stream_maps);
488
    av_free(meta_data_maps);
489

    
490
    av_free(video_codec_name);
491
    av_free(audio_codec_name);
492
    av_free(subtitle_codec_name);
493

    
494
    av_free(video_standard);
495

    
496
    uninit_opts();
497
    av_free(audio_buf);
498
    av_free(audio_out);
499
    allocated_audio_buf_size= allocated_audio_out_size= 0;
500
    av_free(samples);
501

    
502
#if CONFIG_AVFILTER
503
    avfilter_uninit();
504
#endif
505

    
506
    if (received_sigterm) {
507
        fprintf(stderr,
508
            "Received signal %d: terminating.\n",
509
            (int) received_sigterm);
510
        exit (255);
511
    }
512

    
513
    exit(ret); /* not all OS-es handle main() return value */
514
    return ret;
515
}
516

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

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

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

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

    
596
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
597
{
598
    int idx = oc->nb_streams - 1;
599
    AVOutputStream *ost;
600

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

    
617
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
618
{
619
    int i, err;
620
    AVFormatContext *ic;
621
    int nopts = 0;
622

    
623
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
624
    if (err < 0)
625
        return err;
626
    /* copy stream format */
627
    s->nb_streams = 0;
628
    for(i=0;i<ic->nb_streams;i++) {
629
        AVStream *st;
630
        AVCodec *codec;
631

    
632
        s->nb_streams++;
633

    
634
        // FIXME: a more elegant solution is needed
635
        st = av_mallocz(sizeof(AVStream));
636
        memcpy(st, ic->streams[i], sizeof(AVStream));
637
        st->codec = avcodec_alloc_context();
638
        if (!st->codec) {
639
            print_error(filename, AVERROR(ENOMEM));
640
            ffmpeg_exit(1);
641
        }
642
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
643
        s->streams[i] = st;
644

    
645
        codec = avcodec_find_encoder(st->codec->codec_id);
646
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
647
            if (audio_stream_copy) {
648
                st->stream_copy = 1;
649
            } else
650
                choose_sample_fmt(st, codec);
651
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
652
            if (video_stream_copy) {
653
                st->stream_copy = 1;
654
            } else
655
                choose_pixel_fmt(st, codec);
656
        }
657

    
658
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
659
            nopts = 1;
660

    
661
        new_output_stream(s, nb_output_files);
662
    }
663

    
664
    if (!nopts)
665
        s->timestamp = av_gettime();
666

    
667
    av_close_input_file(ic);
668
    return 0;
669
}
670

    
671
static double
672
get_sync_ipts(const AVOutputStream *ost)
673
{
674
    const AVInputStream *ist = ost->sync_ist;
675
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
676
}
677

    
678
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
679
    int ret;
680

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

    
700
        bsfc= bsfc->next;
701
    }
702

    
703
    ret= av_interleaved_write_frame(s, pkt);
704
    if(ret < 0){
705
        print_error("av_interleaved_write_frame()", ret);
706
        ffmpeg_exit(1);
707
    }
708
}
709

    
710
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
711

    
712
static void do_audio_out(AVFormatContext *s,
713
                         AVOutputStream *ost,
714
                         AVInputStream *ist,
715
                         unsigned char *buf, int size)
716
{
717
    uint8_t *buftmp;
718
    int64_t audio_out_size, audio_buf_size;
719
    int64_t allocated_for_size= size;
720

    
721
    int size_out, frame_bytes, ret, resample_changed;
722
    AVCodecContext *enc= ost->st->codec;
723
    AVCodecContext *dec= ist->st->codec;
724
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
725
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
726
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
727

    
728
need_realloc:
729
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
730
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
731
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
732
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
733
    audio_buf_size*= osize*enc->channels;
734

    
735
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
736
    if(coded_bps > 8*osize)
737
        audio_out_size= audio_out_size * coded_bps / (8*osize);
738
    audio_out_size += FF_MIN_BUFFER_SIZE;
739

    
740
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
741
        fprintf(stderr, "Buffer sizes too large\n");
742
        ffmpeg_exit(1);
743
    }
744

    
745
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
746
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
747
    if (!audio_buf || !audio_out){
748
        fprintf(stderr, "Out of memory in do_audio_out\n");
749
        ffmpeg_exit(1);
750
    }
751

    
752
    if (enc->channels != dec->channels)
753
        ost->audio_resample = 1;
754

    
755
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
756
                       ost->resample_channels    != dec->channels   ||
757
                       ost->resample_sample_rate != dec->sample_rate;
758

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

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

    
810
    if(audio_sync_method){
811
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
812
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
813
        double idelta= delta*dec->sample_rate / enc->sample_rate;
814
        int byte_delta= ((int)idelta)*2*dec->channels;
815

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

    
832
                    if(byte_delta > allocated_for_size - size){
833
                        allocated_for_size= byte_delta + (int64_t)size;
834
                        goto need_realloc;
835
                    }
836
                    ist->is_start=0;
837

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

    
858
    if (ost->audio_resample) {
859
        buftmp = audio_buf;
860
        size_out = audio_resample(ost->resample,
861
                                  (short *)buftmp, (short *)buf,
862
                                  size / (dec->channels * isize));
863
        size_out = size_out * enc->channels * osize;
864
    } else {
865
        buftmp = buf;
866
        size_out = size;
867
    }
868

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

    
885
    /* now encode as many frames as possible */
886
    if (enc->frame_size > 1) {
887
        /* output resampled raw samples */
888
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
889
            fprintf(stderr, "av_fifo_realloc2() failed\n");
890
            ffmpeg_exit(1);
891
        }
892
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
893

    
894
        frame_bytes = enc->frame_size * osize * enc->channels;
895

    
896
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
897
            AVPacket pkt;
898
            av_init_packet(&pkt);
899

    
900
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
901

    
902
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
903

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

    
919
            ost->sync_opts += enc->frame_size;
920
        }
921
    } else {
922
        AVPacket pkt;
923
        av_init_packet(&pkt);
924

    
925
        ost->sync_opts += size_out / (osize * enc->channels);
926

    
927
        /* output a pcm frame */
928
        /* determine the size of the coded buffer */
929
        size_out /= osize;
930
        if (coded_bps)
931
            size_out = size_out*coded_bps/8;
932

    
933
        if(size_out > audio_out_size){
934
            fprintf(stderr, "Internal error, buffer size too small\n");
935
            ffmpeg_exit(1);
936
        }
937

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

    
956
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
957
{
958
    AVCodecContext *dec;
959
    AVPicture *picture2;
960
    AVPicture picture_tmp;
961
    uint8_t *buf = 0;
962

    
963
    dec = ist->st->codec;
964

    
965
    /* deinterlace : must be done before any resize */
966
    if (do_deinterlace) {
967
        int size;
968

    
969
        /* create temporary picture */
970
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
971
        buf = av_malloc(size);
972
        if (!buf)
973
            return;
974

    
975
        picture2 = &picture_tmp;
976
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
977

    
978
        if(avpicture_deinterlace(picture2, picture,
979
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
980
            /* if error, do not deinterlace */
981
            fprintf(stderr, "Deinterlacing failed\n");
982
            av_free(buf);
983
            buf = NULL;
984
            picture2 = picture;
985
        }
986
    } else {
987
        picture2 = picture;
988
    }
989

    
990
    if (picture != picture2)
991
        *picture = *picture2;
992
    *bufp = buf;
993
}
994

    
995
/* we begin to correct av delay at this threshold */
996
#define AV_DELAY_MAX 0.100
997

    
998
static void do_subtitle_out(AVFormatContext *s,
999
                            AVOutputStream *ost,
1000
                            AVInputStream *ist,
1001
                            AVSubtitle *sub,
1002
                            int64_t pts)
1003
{
1004
    static uint8_t *subtitle_out = NULL;
1005
    int subtitle_out_max_size = 1024 * 1024;
1006
    int subtitle_out_size, nb, i;
1007
    AVCodecContext *enc;
1008
    AVPacket pkt;
1009

    
1010
    if (pts == AV_NOPTS_VALUE) {
1011
        fprintf(stderr, "Subtitle packets must have a pts\n");
1012
        if (exit_on_error)
1013
            ffmpeg_exit(1);
1014
        return;
1015
    }
1016

    
1017
    enc = ost->st->codec;
1018

    
1019
    if (!subtitle_out) {
1020
        subtitle_out = av_malloc(subtitle_out_max_size);
1021
    }
1022

    
1023
    /* Note: DVB subtitle need one packet to draw them and one other
1024
       packet to clear them */
1025
    /* XXX: signal it in the codec context ? */
1026
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1027
        nb = 2;
1028
    else
1029
        nb = 1;
1030

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

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

    
1061
static int bit_buffer_size= 1024*256;
1062
static uint8_t *bit_buffer= NULL;
1063

    
1064
static void do_video_out(AVFormatContext *s,
1065
                         AVOutputStream *ost,
1066
                         AVInputStream *ist,
1067
                         AVFrame *in_picture,
1068
                         int *frame_size)
1069
{
1070
    int nb_frames, i, ret;
1071
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1072
    AVCodecContext *enc, *dec;
1073
    double sync_ipts;
1074

    
1075
    enc = ost->st->codec;
1076
    dec = ist->st->codec;
1077

    
1078
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1079

    
1080
    /* by default, we output a single frame */
1081
    nb_frames = 1;
1082

    
1083
    *frame_size = 0;
1084

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

    
1110
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1111
    if (nb_frames <= 0)
1112
        return;
1113

    
1114
    formatted_picture = in_picture;
1115
    final_picture = formatted_picture;
1116
    padding_src = formatted_picture;
1117
    resampling_dst = &ost->pict_tmp;
1118

    
1119
    if (   ost->resample_height != ist->st->codec->height
1120
        || ost->resample_width  != ist->st->codec->width
1121
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1122

    
1123
        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));
1124
        if(!ost->video_resample)
1125
            ffmpeg_exit(1);
1126
    }
1127

    
1128
#if !CONFIG_AVFILTER
1129
    if (ost->video_resample) {
1130
        padding_src = NULL;
1131
        final_picture = &ost->pict_tmp;
1132
        if(  ost->resample_height != ist->st->codec->height
1133
          || ost->resample_width  != ist->st->codec->width
1134
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1135

    
1136
            /* initialize a new scaler context */
1137
            sws_freeContext(ost->img_resample_ctx);
1138
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1139
            ost->img_resample_ctx = sws_getContext(
1140
                ist->st->codec->width,
1141
                ist->st->codec->height,
1142
                ist->st->codec->pix_fmt,
1143
                ost->st->codec->width,
1144
                ost->st->codec->height,
1145
                ost->st->codec->pix_fmt,
1146
                sws_flags, NULL, NULL, NULL);
1147
            if (ost->img_resample_ctx == NULL) {
1148
                fprintf(stderr, "Cannot get resampling context\n");
1149
                ffmpeg_exit(1);
1150
            }
1151
        }
1152
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1153
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1154
    }
1155
#endif
1156

    
1157
    /* duplicates frame if needed */
1158
    for(i=0;i<nb_frames;i++) {
1159
        AVPacket pkt;
1160
        av_init_packet(&pkt);
1161
        pkt.stream_index= ost->index;
1162

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

    
1174
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1175
            enc->coded_frame = old_frame;
1176
        } else {
1177
            AVFrame big_picture;
1178

    
1179
            big_picture= *final_picture;
1180
            /* better than nothing: use input picture interlaced
1181
               settings */
1182
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1183
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1184
                if(top_field_first == -1)
1185
                    big_picture.top_field_first = in_picture->top_field_first;
1186
                else
1187
                    big_picture.top_field_first = top_field_first;
1188
            }
1189

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

    
1212
            if(ret>0){
1213
                pkt.data= bit_buffer;
1214
                pkt.size= ret;
1215
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1216
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1217
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1218
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1219
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1220

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

    
1239
static double psnr(double d){
1240
    return -10.0*log(d)/log(10.0);
1241
}
1242

    
1243
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1244
                           int frame_size)
1245
{
1246
    AVCodecContext *enc;
1247
    int frame_number;
1248
    double ti1, bitrate, avg_bitrate;
1249

    
1250
    /* this is executed just the first time do_video_stats is called */
1251
    if (!vstats_file) {
1252
        vstats_file = fopen(vstats_filename, "w");
1253
        if (!vstats_file) {
1254
            perror("fopen");
1255
            ffmpeg_exit(1);
1256
        }
1257
    }
1258

    
1259
    enc = ost->st->codec;
1260
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1261
        frame_number = ost->frame_number;
1262
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1263
        if (enc->flags&CODEC_FLAG_PSNR)
1264
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1265

    
1266
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1267
        /* compute pts value */
1268
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1269
        if (ti1 < 0.01)
1270
            ti1 = 0.01;
1271

    
1272
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1273
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1274
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1275
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1276
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1277
    }
1278
}
1279

    
1280
static void print_report(AVFormatContext **output_files,
1281
                         AVOutputStream **ost_table, int nb_ostreams,
1282
                         int is_last_report)
1283
{
1284
    char buf[1024];
1285
    AVOutputStream *ost;
1286
    AVFormatContext *oc;
1287
    int64_t total_size;
1288
    AVCodecContext *enc;
1289
    int frame_number, vid, i;
1290
    double bitrate, ti1, pts;
1291
    static int64_t last_time = -1;
1292
    static int qp_histogram[52];
1293

    
1294
    if (!is_last_report) {
1295
        int64_t cur_time;
1296
        /* display the report every 0.5 seconds */
1297
        cur_time = av_gettime();
1298
        if (last_time == -1) {
1299
            last_time = cur_time;
1300
            return;
1301
        }
1302
        if ((cur_time - last_time) < 500000)
1303
            return;
1304
        last_time = cur_time;
1305
    }
1306

    
1307

    
1308
    oc = output_files[0];
1309

    
1310
    total_size = avio_size(oc->pb);
1311
    if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1312
        total_size= avio_tell(oc->pb);
1313

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

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

    
1374
    if (verbose || is_last_report) {
1375
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1376

    
1377
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1378
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1379
            (double)total_size / 1024, ti1, bitrate);
1380

    
1381
        if (nb_frames_dup || nb_frames_drop)
1382
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1383
                  nb_frames_dup, nb_frames_drop);
1384

    
1385
        if (verbose >= 0)
1386
            fprintf(stderr, "%s    \r", buf);
1387

    
1388
        fflush(stderr);
1389
    }
1390

    
1391
    if (is_last_report && verbose >= 0){
1392
        int64_t raw= audio_size + video_size + extra_size;
1393
        fprintf(stderr, "\n");
1394
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1395
                video_size/1024.0,
1396
                audio_size/1024.0,
1397
                extra_size/1024.0,
1398
                100.0*(total_size - raw)/raw
1399
        );
1400
    }
1401
}
1402

    
1403
static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1404
{
1405
    int fill_char = 0x00;
1406
    if (sample_fmt == AV_SAMPLE_FMT_U8)
1407
        fill_char = 0x80;
1408
    memset(buf, fill_char, size);
1409
}
1410

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

    
1429
    AVPacket avpkt;
1430
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1431

    
1432
    if(ist->next_pts == AV_NOPTS_VALUE)
1433
        ist->next_pts= ist->pts;
1434

    
1435
    if (pkt == NULL) {
1436
        /* EOF handling */
1437
        av_init_packet(&avpkt);
1438
        avpkt.data = NULL;
1439
        avpkt.size = 0;
1440
        goto handle_eof;
1441
    } else {
1442
        avpkt = *pkt;
1443
    }
1444

    
1445
    if(pkt->dts != AV_NOPTS_VALUE)
1446
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1447
    if(pkt->pts != AV_NOPTS_VALUE)
1448
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1449

    
1450
    //while we have more to decode or while the decoder did output something on EOF
1451
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1452
        uint8_t *data_buf, *decoded_data_buf;
1453
        int data_size, decoded_data_size;
1454
    handle_eof:
1455
        ist->pts= ist->next_pts;
1456

    
1457
        if(avpkt.size && avpkt.size != pkt->size &&
1458
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1459
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1460
            ist->showed_multi_packet_warning=1;
1461
        }
1462

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

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

    
1556
        buffer_to_free = NULL;
1557
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1558
            pre_process_video_frame(ist, (AVPicture *)&picture,
1559
                                    &buffer_to_free);
1560
        }
1561

    
1562
#if CONFIG_AVFILTER
1563
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1564
            AVRational sar;
1565
            if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1566
            else                                  sar = ist->st->codec->sample_aspect_ratio;
1567
            // add it to be filtered
1568
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1569
                                     ist->pts,
1570
                                     sar);
1571
        }
1572
#endif
1573

    
1574
        // preprocess audio (volume)
1575
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1576
            if (audio_volume != 256) {
1577
                short *volp;
1578
                volp = samples;
1579
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1580
                    int v = ((*volp) * audio_volume + 128) >> 8;
1581
                    if (v < -32768) v = -32768;
1582
                    if (v >  32767) v = 32767;
1583
                    *volp++ = v;
1584
                }
1585
            }
1586
        }
1587

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

    
1613
                ost = ost_table[i];
1614
                if (ost->source_index == ist_index) {
1615
                    os = output_files[ost->file_index];
1616

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

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

    
1647
                        av_init_packet(&opkt);
1648

    
1649
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1650
                            continue;
1651

    
1652
                        /* no reencoding needed : output the packet directly */
1653
                        /* force the input stream PTS */
1654

    
1655
                        avcodec_get_frame_defaults(&avframe);
1656
                        ost->st->codec->coded_frame= &avframe;
1657
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1658

    
1659
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1660
                            audio_size += data_size;
1661
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1662
                            video_size += data_size;
1663
                            ost->sync_opts++;
1664
                        }
1665

    
1666
                        opkt.stream_index= ost->index;
1667
                        if(pkt->pts != AV_NOPTS_VALUE)
1668
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1669
                        else
1670
                            opkt.pts= AV_NOPTS_VALUE;
1671

    
1672
                        if (pkt->dts == AV_NOPTS_VALUE)
1673
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1674
                        else
1675
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1676
                        opkt.dts -= ost_tb_start_time;
1677

    
1678
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1679
                        opkt.flags= pkt->flags;
1680

    
1681
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1682
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1683
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1684
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1685
                           ) {
1686
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1687
                                opkt.destruct= av_destruct_packet;
1688
                        } else {
1689
                            opkt.data = data_buf;
1690
                            opkt.size = data_size;
1691
                        }
1692

    
1693
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1694
                        ost->st->codec->frame_number++;
1695
                        ost->frame_number++;
1696
                        av_free_packet(&opkt);
1697
                    }
1698
                }
1699
            }
1700

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

    
1719
        for(i=0;i<nb_ostreams;i++) {
1720
            ost = ost_table[i];
1721
            if (ost->source_index == ist_index) {
1722
                AVCodecContext *enc= ost->st->codec;
1723
                os = output_files[ost->file_index];
1724

    
1725
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1726
                    continue;
1727
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1728
                    continue;
1729

    
1730
                if (ost->encoding_needed) {
1731
                    for(;;) {
1732
                        AVPacket pkt;
1733
                        int fifo_bytes;
1734
                        av_init_packet(&pkt);
1735
                        pkt.stream_index= ost->index;
1736

    
1737
                        switch(ost->st->codec->codec_type) {
1738
                        case AVMEDIA_TYPE_AUDIO:
1739
                            fifo_bytes = av_fifo_size(ost->fifo);
1740
                            ret = 0;
1741
                            /* encode any samples remaining in fifo */
1742
                            if (fifo_bytes > 0) {
1743
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1744
                                int fs_tmp = enc->frame_size;
1745

    
1746
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1747
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1748
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1749
                                } else { /* pad */
1750
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1751
                                    if (allocated_audio_buf_size < frame_bytes)
1752
                                        ffmpeg_exit(1);
1753
                                    generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1754
                                }
1755

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

    
1788
                        if(ret<=0)
1789
                            break;
1790
                        pkt.data= bit_buffer;
1791
                        pkt.size= ret;
1792
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1793
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1794
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1795
                    }
1796
                }
1797
            }
1798
        }
1799
    }
1800

    
1801
    return 0;
1802
 fail_decode:
1803
    return -1;
1804
}
1805

    
1806
static void print_sdp(AVFormatContext **avc, int n)
1807
{
1808
    char sdp[2048];
1809

    
1810
    av_sdp_create(avc, n, sdp, sizeof(sdp));
1811
    printf("SDP:\n%s\n", sdp);
1812
    fflush(stdout);
1813
}
1814

    
1815
static int copy_chapters(int infile, int outfile)
1816
{
1817
    AVFormatContext *is = input_files[infile];
1818
    AVFormatContext *os = output_files[outfile];
1819
    int i;
1820

    
1821
    for (i = 0; i < is->nb_chapters; i++) {
1822
        AVChapter *in_ch = is->chapters[i], *out_ch;
1823
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1824
                                      AV_TIME_BASE_Q, in_ch->time_base);
1825
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1826
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1827

    
1828

    
1829
        if (in_ch->end < ts_off)
1830
            continue;
1831
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1832
            break;
1833

    
1834
        out_ch = av_mallocz(sizeof(AVChapter));
1835
        if (!out_ch)
1836
            return AVERROR(ENOMEM);
1837

    
1838
        out_ch->id        = in_ch->id;
1839
        out_ch->time_base = in_ch->time_base;
1840
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1841
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1842

    
1843
        if (metadata_chapters_autocopy)
1844
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1845

    
1846
        os->nb_chapters++;
1847
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1848
        if (!os->chapters)
1849
            return AVERROR(ENOMEM);
1850
        os->chapters[os->nb_chapters - 1] = out_ch;
1851
    }
1852
    return 0;
1853
}
1854

    
1855
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1856
                                    AVCodecContext *avctx)
1857
{
1858
    char *p;
1859
    int n = 1, i;
1860
    int64_t t;
1861

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

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

    
1899
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1900
    if (!file_table)
1901
        goto fail;
1902

    
1903
    /* input stream init */
1904
    j = 0;
1905
    for(i=0;i<nb_input_files;i++) {
1906
        is = input_files[i];
1907
        file_table[i].ist_index = j;
1908
        file_table[i].nb_streams = is->nb_streams;
1909
        j += is->nb_streams;
1910
    }
1911
    nb_istreams = j;
1912

    
1913
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1914
    if (!ist_table)
1915
        goto fail;
1916

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

    
1934
            if (rate_emu) {
1935
                ist->start = av_gettime();
1936
            }
1937
        }
1938
    }
1939

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

    
1958
    /* Sanity check the mapping args -- do the input files & streams exist? */
1959
    for(i=0;i<nb_stream_maps;i++) {
1960
        int fi = stream_maps[i].file_index;
1961
        int si = stream_maps[i].stream_index;
1962

    
1963
        if (fi < 0 || fi > nb_input_files - 1 ||
1964
            si < 0 || si > file_table[fi].nb_streams - 1) {
1965
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1966
            ret = AVERROR(EINVAL);
1967
            goto fail;
1968
        }
1969
        fi = stream_maps[i].sync_file_index;
1970
        si = stream_maps[i].sync_stream_index;
1971
        if (fi < 0 || fi > nb_input_files - 1 ||
1972
            si < 0 || si > file_table[fi].nb_streams - 1) {
1973
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1974
            ret = AVERROR(EINVAL);
1975
            goto fail;
1976
        }
1977
    }
1978

    
1979
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1980
    if (!ost_table)
1981
        goto fail;
1982
    n = 0;
1983
    for(k=0;k<nb_output_files;k++) {
1984
        os = output_files[k];
1985
        for(i=0;i<os->nb_streams;i++,n++) {
1986
            int found;
1987
            ost = ost_table[n] = output_streams_for_file[k][i];
1988
            ost->st = os->streams[i];
1989
            if (nb_stream_maps > 0) {
1990
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1991
                    stream_maps[n].stream_index;
1992

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

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

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

    
2062
    /* for each output stream, we compute the right encoding parameters */
2063
    for(i=0;i<nb_ostreams;i++) {
2064
        ost = ost_table[i];
2065
        os = output_files[ost->file_index];
2066
        ist = ist_table[ost->source_index];
2067

    
2068
        codec = ost->st->codec;
2069
        icodec = ist->st->codec;
2070

    
2071
        if (metadata_streams_autocopy)
2072
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2073
                             AV_METADATA_DONT_OVERWRITE);
2074

    
2075
        ost->st->disposition = ist->st->disposition;
2076
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2077
        codec->chroma_sample_location = icodec->chroma_sample_location;
2078

    
2079
        if (ost->st->stream_copy) {
2080
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2081

    
2082
            if (extra_size > INT_MAX)
2083
                goto fail;
2084

    
2085
            /* if stream_copy is selected, no need to decode or encode */
2086
            codec->codec_id = icodec->codec_id;
2087
            codec->codec_type = icodec->codec_type;
2088

    
2089
            if(!codec->codec_tag){
2090
                if(   !os->oformat->codec_tag
2091
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2092
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2093
                    codec->codec_tag = icodec->codec_tag;
2094
            }
2095

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

    
2186
                    ost->original_height = icodec->height;
2187
                    ost->original_width  = icodec->width;
2188
#endif
2189
                    codec->bits_per_raw_sample= 0;
2190
                }
2191
                ost->resample_height = icodec->height;
2192
                ost->resample_width  = icodec->width;
2193
                ost->resample_pix_fmt= icodec->pix_fmt;
2194
                ost->encoding_needed = 1;
2195
                ist->decoding_needed = 1;
2196

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

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

    
2245
    if (!bit_buffer)
2246
        bit_buffer = av_malloc(bit_buffer_size);
2247
    if (!bit_buffer) {
2248
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2249
                bit_buffer_size);
2250
        ret = AVERROR(ENOMEM);
2251
        goto fail;
2252
    }
2253

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

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

    
2311
    /* init pts */
2312
    for(i=0;i<nb_istreams;i++) {
2313
        AVStream *st;
2314
        ist = ist_table[i];
2315
        st= ist->st;
2316
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2317
        ist->next_pts = AV_NOPTS_VALUE;
2318
        init_pts_correction(&ist->pts_ctx);
2319
        ist->is_start = 1;
2320
    }
2321

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

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

    
2336
        int out_file_index = meta_data_maps[i][0].file;
2337
        int in_file_index = meta_data_maps[i][1].file;
2338
        if (in_file_index < 0 || out_file_index < 0)
2339
            continue;
2340
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2341
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2342

    
2343
        files[0] = output_files[out_file_index];
2344
        files[1] = input_files[in_file_index];
2345

    
2346
        for (j = 0; j < 2; j++) {
2347
            AVMetaDataMap *map = &meta_data_maps[i][j];
2348

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

    
2368
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2369
    }
2370

    
2371
    /* copy global metadata by default */
2372
    if (metadata_global_autocopy) {
2373

    
2374
        for (i = 0; i < nb_output_files; i++)
2375
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2376
                             AV_METADATA_DONT_OVERWRITE);
2377
    }
2378

    
2379
    /* copy chapters according to chapter maps */
2380
    for (i = 0; i < nb_chapter_maps; i++) {
2381
        int infile  = chapter_maps[i].in_file;
2382
        int outfile = chapter_maps[i].out_file;
2383

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

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

    
2405
            for (j = 0; j < nb_output_files; j++)
2406
                if ((ret = copy_chapters(i, j)) < 0)
2407
                    goto dump_format;
2408
            break;
2409
        }
2410

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

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

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

    
2449
    if (ret) {
2450
        fprintf(stderr, "%s\n", error);
2451
        goto fail;
2452
    }
2453

    
2454
    if (want_sdp) {
2455
        print_sdp(output_files, nb_output_files);
2456
    }
2457

    
2458
    if (!using_stdin && verbose >= 0) {
2459
#if HAVE_KBHIT
2460
        fprintf(stderr, "Press [q] to stop encoding\n");
2461
#else
2462
        fprintf(stderr, "Press ctrl-c to stop encoding\n");
2463
#endif
2464
        avio_set_interrupt_cb(decode_interrupt_cb);
2465
    }
2466
    term_init();
2467

    
2468
    timer_start = av_gettime();
2469

    
2470
    for(; received_sigterm == 0;) {
2471
        int file_index, ist_index;
2472
        AVPacket pkt;
2473
        double ipts_min;
2474
        double opts_min;
2475

    
2476
    redo:
2477
        ipts_min= 1e100;
2478
        opts_min= 1e100;
2479
        /* if 'q' pressed, exits */
2480
        if (!using_stdin) {
2481
            if (q_pressed)
2482
                break;
2483
            /* read_key() returns 0 on EOF */
2484
            key = read_key();
2485
            if (key == 'q')
2486
                break;
2487
        }
2488

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

    
2527
        /* finish if limit size exhausted */
2528
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2529
            break;
2530

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

    
2547
        no_packet_count=0;
2548
        memset(no_packet, 0, sizeof(no_packet));
2549

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

    
2563
        if (pkt.dts != AV_NOPTS_VALUE)
2564
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2565
        if (pkt.pts != AV_NOPTS_VALUE)
2566
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2567

    
2568
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2569
            && input_files_ts_scale[file_index][pkt.stream_index]){
2570
            if(pkt.pts != AV_NOPTS_VALUE)
2571
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2572
            if(pkt.dts != AV_NOPTS_VALUE)
2573
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2574
        }
2575

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

    
2591
        /* finish if recording time exhausted */
2592
        if (recording_time != INT64_MAX &&
2593
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2594
            ist->is_past_recording_time = 1;
2595
            goto discard_packet;
2596
        }
2597

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

    
2601
            if (verbose >= 0)
2602
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2603
                        ist->file_index, ist->index);
2604
            if (exit_on_error)
2605
                ffmpeg_exit(1);
2606
            av_free_packet(&pkt);
2607
            goto redo;
2608
        }
2609

    
2610
    discard_packet:
2611
        av_free_packet(&pkt);
2612

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

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

    
2625
    term_exit();
2626

    
2627
    /* write the trailer if needed and close file */
2628
    for(i=0;i<nb_output_files;i++) {
2629
        os = output_files[i];
2630
        av_write_trailer(os);
2631
    }
2632

    
2633
    /* dump report by using the first video and audio streams */
2634
    print_report(output_files, ost_table, nb_ostreams, 1);
2635

    
2636
    /* close each encoder */
2637
    for(i=0;i<nb_ostreams;i++) {
2638
        ost = ost_table[i];
2639
        if (ost->encoding_needed) {
2640
            av_freep(&ost->st->codec->stats_in);
2641
            avcodec_close(ost->st->codec);
2642
        }
2643
    }
2644

    
2645
    /* close each decoder */
2646
    for(i=0;i<nb_istreams;i++) {
2647
        ist = ist_table[i];
2648
        if (ist->decoding_needed) {
2649
            avcodec_close(ist->st->codec);
2650
        }
2651
    }
2652
#if CONFIG_AVFILTER
2653
    avfilter_graph_free(&graph);
2654
#endif
2655

    
2656
    /* finished ! */
2657
    ret = 0;
2658

    
2659
 fail:
2660
    av_freep(&bit_buffer);
2661
    av_free(file_table);
2662

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

    
2699
static void opt_format(const char *arg)
2700
{
2701
    last_asked_format = arg;
2702
}
2703

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

    
2709
static int opt_me_threshold(const char *opt, const char *arg)
2710
{
2711
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2712
    return 0;
2713
}
2714

    
2715
static int opt_verbose(const char *opt, const char *arg)
2716
{
2717
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2718
    return 0;
2719
}
2720

    
2721
static int opt_frame_rate(const char *opt, const char *arg)
2722
{
2723
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2724
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2725
        ffmpeg_exit(1);
2726
    }
2727
    return 0;
2728
}
2729

    
2730
static int opt_bitrate(const char *opt, const char *arg)
2731
{
2732
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2733

    
2734
    opt_default(opt, arg);
2735

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

    
2739
    return 0;
2740
}
2741

    
2742
static int opt_frame_crop(const char *opt, const char *arg)
2743
{
2744
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2745
    return AVERROR(EINVAL);
2746
}
2747

    
2748
static void opt_frame_size(const char *arg)
2749
{
2750
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2751
        fprintf(stderr, "Incorrect frame size\n");
2752
        ffmpeg_exit(1);
2753
    }
2754
}
2755

    
2756
static int opt_pad(const char *opt, const char *arg) {
2757
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2758
    return -1;
2759
}
2760

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

    
2775
static void opt_frame_aspect_ratio(const char *arg)
2776
{
2777
    int x = 0, y = 0;
2778
    double ar = 0;
2779
    const char *p;
2780
    char *end;
2781

    
2782
    p = strchr(arg, ':');
2783
    if (p) {
2784
        x = strtol(arg, &end, 10);
2785
        if (end == p)
2786
            y = strtol(end+1, &end, 10);
2787
        if (x > 0 && y > 0)
2788
            ar = (double)x / (double)y;
2789
    } else
2790
        ar = strtod(arg, NULL);
2791

    
2792
    if (!ar) {
2793
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2794
        ffmpeg_exit(1);
2795
    }
2796
    frame_aspect_ratio = ar;
2797

    
2798
    x = vfilters ? strlen(vfilters) : 0;
2799
    vfilters = av_realloc(vfilters, x+100);
2800
    snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2801
}
2802

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

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

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

    
2815
    return 0;
2816
}
2817

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

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

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

    
2843
static void opt_audio_sample_fmt(const char *arg)
2844
{
2845
    if (strcmp(arg, "list")) {
2846
        audio_sample_fmt = av_get_sample_fmt(arg);
2847
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2848
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2849
            ffmpeg_exit(1);
2850
        }
2851
    } else {
2852
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2853
        ffmpeg_exit(0);
2854
    }
2855
}
2856

    
2857
static int opt_audio_rate(const char *opt, const char *arg)
2858
{
2859
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2860
    return 0;
2861
}
2862

    
2863
static int opt_audio_channels(const char *opt, const char *arg)
2864
{
2865
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2866
    return 0;
2867
}
2868

    
2869
static void opt_video_channel(const char *arg)
2870
{
2871
    video_channel = strtol(arg, NULL, 0);
2872
}
2873

    
2874
static void opt_video_standard(const char *arg)
2875
{
2876
    video_standard = av_strdup(arg);
2877
}
2878

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

    
2890
static void opt_audio_codec(const char *arg)
2891
{
2892
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2893
}
2894

    
2895
static void opt_video_codec(const char *arg)
2896
{
2897
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2898
}
2899

    
2900
static void opt_subtitle_codec(const char *arg)
2901
{
2902
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2903
}
2904

    
2905
static int opt_codec_tag(const char *opt, const char *arg)
2906
{
2907
    char *tail;
2908
    uint32_t *codec_tag;
2909

    
2910
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2911
                !strcmp(opt, "vtag") ? &video_codec_tag :
2912
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2913
    if (!codec_tag)
2914
        return -1;
2915

    
2916
    *codec_tag = strtol(arg, &tail, 0);
2917
    if (!tail || *tail)
2918
        *codec_tag = AV_RL32(arg);
2919

    
2920
    return 0;
2921
}
2922

    
2923
static void opt_map(const char *arg)
2924
{
2925
    AVStreamMap *m;
2926
    char *p;
2927

    
2928
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2929
    m = &stream_maps[nb_stream_maps-1];
2930

    
2931
    m->file_index = strtol(arg, &p, 0);
2932
    if (*p)
2933
        p++;
2934

    
2935
    m->stream_index = strtol(p, &p, 0);
2936
    if (*p) {
2937
        p++;
2938
        m->sync_file_index = strtol(p, &p, 0);
2939
        if (*p)
2940
            p++;
2941
        m->sync_stream_index = strtol(p, &p, 0);
2942
    } else {
2943
        m->sync_file_index = m->file_index;
2944
        m->sync_stream_index = m->stream_index;
2945
    }
2946
}
2947

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

    
2969
static void opt_map_metadata(const char *arg)
2970
{
2971
    AVMetaDataMap *m, *m1;
2972
    char *p;
2973

    
2974
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2975
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2976

    
2977
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
2978
    m->file = strtol(arg, &p, 0);
2979
    parse_meta_type(p, &m->type, &m->index, &p);
2980
    if (*p)
2981
        p++;
2982

    
2983
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2984
    m1->file = strtol(p, &p, 0);
2985
    parse_meta_type(p, &m1->type, &m1->index, &p);
2986

    
2987
    if (m->type == 'g' || m1->type == 'g')
2988
        metadata_global_autocopy = 0;
2989
    if (m->type == 's' || m1->type == 's')
2990
        metadata_streams_autocopy = 0;
2991
    if (m->type == 'c' || m1->type == 'c')
2992
        metadata_chapters_autocopy = 0;
2993
}
2994

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

    
3002
static void opt_map_chapters(const char *arg)
3003
{
3004
    AVChapterMap *c;
3005
    char *p;
3006

    
3007
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3008
                              nb_chapter_maps + 1);
3009
    c = &chapter_maps[nb_chapter_maps - 1];
3010
    c->out_file = strtol(arg, &p, 0);
3011
    if (*p)
3012
        p++;
3013

    
3014
    c->in_file = strtol(p, &p, 0);
3015
}
3016

    
3017
static void opt_input_ts_scale(const char *arg)
3018
{
3019
    unsigned int stream;
3020
    double scale;
3021
    char *p;
3022

    
3023
    stream = strtol(arg, &p, 0);
3024
    if (*p)
3025
        p++;
3026
    scale= strtod(p, &p);
3027

    
3028
    if(stream >= MAX_STREAMS)
3029
        ffmpeg_exit(1);
3030

    
3031
    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);
3032
    input_files_ts_scale[nb_input_files][stream]= scale;
3033
}
3034

    
3035
static int opt_recording_time(const char *opt, const char *arg)
3036
{
3037
    recording_time = parse_time_or_die(opt, arg, 1);
3038
    return 0;
3039
}
3040

    
3041
static int opt_start_time(const char *opt, const char *arg)
3042
{
3043
    start_time = parse_time_or_die(opt, arg, 1);
3044
    return 0;
3045
}
3046

    
3047
static int opt_recording_timestamp(const char *opt, const char *arg)
3048
{
3049
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3050
    return 0;
3051
}
3052

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

    
3059
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3060
{
3061
    const char *codec_string = encoder ? "encoder" : "decoder";
3062
    AVCodec *codec;
3063

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

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

    
3101
    if (last_asked_format) {
3102
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3103
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3104
            ffmpeg_exit(1);
3105
        }
3106
        last_asked_format = NULL;
3107
    }
3108

    
3109
    if (!strcmp(filename, "-"))
3110
        filename = "pipe:";
3111

    
3112
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3113
                    !strcmp(filename, "/dev/stdin");
3114

    
3115
    /* get default parameters from command line */
3116
    ic = avformat_alloc_context();
3117
    if (!ic) {
3118
        print_error(filename, AVERROR(ENOMEM));
3119
        ffmpeg_exit(1);
3120
    }
3121

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

    
3135
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3136

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

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

    
3178
    ic->loop_input = loop_input;
3179

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

    
3189
    timestamp = start_time;
3190
    /* add the stream start time */
3191
    if (ic->start_time != AV_NOPTS_VALUE)
3192
        timestamp += ic->start_time;
3193

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

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

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

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

    
3257
                    (float)rfps / rfps_base, rfps, rfps_base);
3258
            }
3259
            /* update the current frame rate to match the stream frame rate */
3260
            frame_rate.num = rfps;
3261
            frame_rate.den = rfps_base;
3262

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

    
3283
    input_files[nb_input_files] = ic;
3284
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3285
    /* dump the file content */
3286
    if (verbose >= 0)
3287
        av_dump_format(ic, nb_input_files, filename, 0);
3288

    
3289
    nb_input_files++;
3290

    
3291
    video_channel = 0;
3292

    
3293
    av_freep(&video_codec_name);
3294
    av_freep(&audio_codec_name);
3295
    av_freep(&subtitle_codec_name);
3296
}
3297

    
3298
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3299
                                         int *has_subtitle_ptr)
3300
{
3301
    int has_video, has_audio, has_subtitle, i, j;
3302
    AVFormatContext *ic;
3303

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

    
3335
static void new_video_stream(AVFormatContext *oc, int file_idx)
3336
{
3337
    AVStream *st;
3338
    AVOutputStream *ost;
3339
    AVCodecContext *video_enc;
3340
    enum CodecID codec_id = CODEC_ID_NONE;
3341
    AVCodec *codec= NULL;
3342

    
3343
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3344
    if (!st) {
3345
        fprintf(stderr, "Could not alloc stream\n");
3346
        ffmpeg_exit(1);
3347
    }
3348
    ost = new_output_stream(oc, file_idx);
3349

    
3350
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3351
    if(!video_stream_copy){
3352
        if (video_codec_name) {
3353
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3354
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3355
            codec = avcodec_find_encoder_by_name(video_codec_name);
3356
            output_codecs[nb_output_codecs-1] = codec;
3357
        } else {
3358
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3359
            codec = avcodec_find_encoder(codec_id);
3360
        }
3361
    }
3362

    
3363
    avcodec_get_context_defaults3(st->codec, codec);
3364
    ost->bitstream_filters = video_bitstream_filters;
3365
    video_bitstream_filters= NULL;
3366

    
3367
    st->codec->thread_count= thread_count;
3368

    
3369
    video_enc = st->codec;
3370

    
3371
    if(video_codec_tag)
3372
        video_enc->codec_tag= video_codec_tag;
3373

    
3374
    if(   (video_global_header&1)
3375
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3376
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3377
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3378
    }
3379
    if(video_global_header&2){
3380
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3381
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3382
    }
3383

    
3384
    if (video_stream_copy) {
3385
        st->stream_copy = 1;
3386
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3387
        video_enc->sample_aspect_ratio =
3388
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3389
    } else {
3390
        const char *p;
3391
        int i;
3392
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3393

    
3394
        video_enc->codec_id = codec_id;
3395
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3396

    
3397
        if (codec && codec->supported_framerates && !force_fps)
3398
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3399
        video_enc->time_base.den = fps.num;
3400
        video_enc->time_base.num = fps.den;
3401

    
3402
        video_enc->width = frame_width;
3403
        video_enc->height = frame_height;
3404
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3405
        video_enc->pix_fmt = frame_pix_fmt;
3406
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3407

    
3408
        choose_pixel_fmt(st, codec);
3409

    
3410
        if (intra_only)
3411
            video_enc->gop_size = 0;
3412
        if (video_qscale || same_quality) {
3413
            video_enc->flags |= CODEC_FLAG_QSCALE;
3414
            video_enc->global_quality=
3415
                st->quality = FF_QP2LAMBDA * video_qscale;
3416
        }
3417

    
3418
        if(intra_matrix)
3419
            video_enc->intra_matrix = intra_matrix;
3420
        if(inter_matrix)
3421
            video_enc->inter_matrix = inter_matrix;
3422

    
3423
        p= video_rc_override_string;
3424
        for(i=0; p; i++){
3425
            int start, end, q;
3426
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3427
            if(e!=3){
3428
                fprintf(stderr, "error parsing rc_override\n");
3429
                ffmpeg_exit(1);
3430
            }
3431
            video_enc->rc_override=
3432
                av_realloc(video_enc->rc_override,
3433
                           sizeof(RcOverride)*(i+1));
3434
            video_enc->rc_override[i].start_frame= start;
3435
            video_enc->rc_override[i].end_frame  = end;
3436
            if(q>0){
3437
                video_enc->rc_override[i].qscale= q;
3438
                video_enc->rc_override[i].quality_factor= 1.0;
3439
            }
3440
            else{
3441
                video_enc->rc_override[i].qscale= 0;
3442
                video_enc->rc_override[i].quality_factor= -q/100.0;
3443
            }
3444
            p= strchr(p, '/');
3445
            if(p) p++;
3446
        }
3447
        video_enc->rc_override_count=i;
3448
        if (!video_enc->rc_initial_buffer_occupancy)
3449
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3450
        video_enc->me_threshold= me_threshold;
3451
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3452

    
3453
        if (do_psnr)
3454
            video_enc->flags|= CODEC_FLAG_PSNR;
3455

    
3456
        /* two pass mode */
3457
        if (do_pass) {
3458
            if (do_pass == 1) {
3459
                video_enc->flags |= CODEC_FLAG_PASS1;
3460
            } else {
3461
                video_enc->flags |= CODEC_FLAG_PASS2;
3462
            }
3463
        }
3464

    
3465
        if (forced_key_frames)
3466
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3467
    }
3468
    if (video_language) {
3469
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3470
        av_freep(&video_language);
3471
    }
3472

    
3473
    /* reset some key parameters */
3474
    video_disable = 0;
3475
    av_freep(&video_codec_name);
3476
    av_freep(&forced_key_frames);
3477
    video_stream_copy = 0;
3478
    frame_pix_fmt = PIX_FMT_NONE;
3479
}
3480

    
3481
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3482
{
3483
    AVStream *st;
3484
    AVOutputStream *ost;
3485
    AVCodec *codec= NULL;
3486
    AVCodecContext *audio_enc;
3487
    enum CodecID codec_id = CODEC_ID_NONE;
3488

    
3489
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3490
    if (!st) {
3491
        fprintf(stderr, "Could not alloc stream\n");
3492
        ffmpeg_exit(1);
3493
    }
3494
    ost = new_output_stream(oc, file_idx);
3495

    
3496
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3497
    if(!audio_stream_copy){
3498
        if (audio_codec_name) {
3499
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3500
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3501
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3502
            output_codecs[nb_output_codecs-1] = codec;
3503
        } else {
3504
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3505
            codec = avcodec_find_encoder(codec_id);
3506
        }
3507
    }
3508

    
3509
    avcodec_get_context_defaults3(st->codec, codec);
3510

    
3511
    ost->bitstream_filters = audio_bitstream_filters;
3512
    audio_bitstream_filters= NULL;
3513

    
3514
    st->codec->thread_count= thread_count;
3515

    
3516
    audio_enc = st->codec;
3517
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3518

    
3519
    if(audio_codec_tag)
3520
        audio_enc->codec_tag= audio_codec_tag;
3521

    
3522
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3523
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3524
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3525
    }
3526
    if (audio_stream_copy) {
3527
        st->stream_copy = 1;
3528
        audio_enc->channels = audio_channels;
3529
        audio_enc->sample_rate = audio_sample_rate;
3530
    } else {
3531
        audio_enc->codec_id = codec_id;
3532
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3533

    
3534
        if (audio_qscale > QSCALE_NONE) {
3535
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3536
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3537
        }
3538
        audio_enc->channels = audio_channels;
3539
        audio_enc->sample_fmt = audio_sample_fmt;
3540
        audio_enc->sample_rate = audio_sample_rate;
3541
        audio_enc->channel_layout = channel_layout;
3542
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3543
            audio_enc->channel_layout = 0;
3544
        choose_sample_fmt(st, codec);
3545
        choose_sample_rate(st, codec);
3546
    }
3547
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3548
    if (audio_language) {
3549
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3550
        av_freep(&audio_language);
3551
    }
3552

    
3553
    /* reset some key parameters */
3554
    audio_disable = 0;
3555
    av_freep(&audio_codec_name);
3556
    audio_stream_copy = 0;
3557
}
3558

    
3559
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3560
{
3561
    AVStream *st;
3562
    AVOutputStream *ost;
3563
    AVCodec *codec=NULL;
3564
    AVCodecContext *subtitle_enc;
3565
    enum CodecID codec_id = CODEC_ID_NONE;
3566

    
3567
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3568
    if (!st) {
3569
        fprintf(stderr, "Could not alloc stream\n");
3570
        ffmpeg_exit(1);
3571
    }
3572
    ost = new_output_stream(oc, file_idx);
3573
    subtitle_enc = st->codec;
3574
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3575
    if(!subtitle_stream_copy){
3576
        if (subtitle_codec_name) {
3577
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3578
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3579
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3580
        } else {
3581
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3582
            codec = avcodec_find_encoder(codec_id);
3583
        }
3584
    }
3585
    avcodec_get_context_defaults3(st->codec, codec);
3586

    
3587
    ost->bitstream_filters = subtitle_bitstream_filters;
3588
    subtitle_bitstream_filters= NULL;
3589

    
3590
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3591

    
3592
    if(subtitle_codec_tag)
3593
        subtitle_enc->codec_tag= subtitle_codec_tag;
3594

    
3595
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3596
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3597
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3598
    }
3599
    if (subtitle_stream_copy) {
3600
        st->stream_copy = 1;
3601
    } else {
3602
        subtitle_enc->codec_id = codec_id;
3603
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3604
    }
3605

    
3606
    if (subtitle_language) {
3607
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3608
        av_freep(&subtitle_language);
3609
    }
3610

    
3611
    subtitle_disable = 0;
3612
    av_freep(&subtitle_codec_name);
3613
    subtitle_stream_copy = 0;
3614
}
3615

    
3616
static int opt_new_stream(const char *opt, const char *arg)
3617
{
3618
    AVFormatContext *oc;
3619
    int file_idx = nb_output_files - 1;
3620
    if (nb_output_files <= 0) {
3621
        fprintf(stderr, "At least one output file must be specified\n");
3622
        ffmpeg_exit(1);
3623
    }
3624
    oc = output_files[file_idx];
3625

    
3626
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3627
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3628
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3629
    else av_assert0(0);
3630
    return 0;
3631
}
3632

    
3633
/* arg format is "output-stream-index:streamid-value". */
3634
static int opt_streamid(const char *opt, const char *arg)
3635
{
3636
    int idx;
3637
    char *p;
3638
    char idx_str[16];
3639

    
3640
    strncpy(idx_str, arg, sizeof(idx_str));
3641
    idx_str[sizeof(idx_str)-1] = '\0';
3642
    p = strchr(idx_str, ':');
3643
    if (!p) {
3644
        fprintf(stderr,
3645
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3646
                arg, opt);
3647
        ffmpeg_exit(1);
3648
    }
3649
    *p++ = '\0';
3650
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3651
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3652
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3653
    return 0;
3654
}
3655

    
3656
static void opt_output_file(const char *filename)
3657
{
3658
    AVFormatContext *oc;
3659
    int err, use_video, use_audio, use_subtitle;
3660
    int input_has_video, input_has_audio, input_has_subtitle;
3661
    AVFormatParameters params, *ap = &params;
3662
    AVOutputFormat *file_oformat;
3663

    
3664
    if (!strcmp(filename, "-"))
3665
        filename = "pipe:";
3666

    
3667
    oc = avformat_alloc_context();
3668
    if (!oc) {
3669
        print_error(filename, AVERROR(ENOMEM));
3670
        ffmpeg_exit(1);
3671
    }
3672

    
3673
    if (last_asked_format) {
3674
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3675
        if (!file_oformat) {
3676
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3677
            ffmpeg_exit(1);
3678
        }
3679
        last_asked_format = NULL;
3680
    } else {
3681
        file_oformat = av_guess_format(NULL, filename, NULL);
3682
        if (!file_oformat) {
3683
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3684
                    filename);
3685
            ffmpeg_exit(1);
3686
        }
3687
    }
3688

    
3689
    oc->oformat = file_oformat;
3690
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3691

    
3692
    if (!strcmp(file_oformat->name, "ffm") &&
3693
        av_strstart(filename, "http:", NULL)) {
3694
        /* special case for files sent to ffserver: we get the stream
3695
           parameters from ffserver */
3696
        int err = read_ffserver_streams(oc, filename);
3697
        if (err < 0) {
3698
            print_error(filename, err);
3699
            ffmpeg_exit(1);
3700
        }
3701
    } else {
3702
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3703
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3704
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3705

    
3706
        /* disable if no corresponding type found and at least one
3707
           input file */
3708
        if (nb_input_files > 0) {
3709
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3710
                                         &input_has_subtitle);
3711
            if (!input_has_video)
3712
                use_video = 0;
3713
            if (!input_has_audio)
3714
                use_audio = 0;
3715
            if (!input_has_subtitle)
3716
                use_subtitle = 0;
3717
        }
3718

    
3719
        /* manual disable */
3720
        if (audio_disable)    use_audio    = 0;
3721
        if (video_disable)    use_video    = 0;
3722
        if (subtitle_disable) use_subtitle = 0;
3723

    
3724
        if (use_video)    new_video_stream(oc, nb_output_files);
3725
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3726
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3727

    
3728
        oc->timestamp = recording_timestamp;
3729

    
3730
        av_metadata_copy(&oc->metadata, metadata, 0);
3731
        av_metadata_free(&metadata);
3732
    }
3733

    
3734
    output_files[nb_output_files++] = oc;
3735

    
3736
    /* check filename in case of an image number is expected */
3737
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3738
        if (!av_filename_number_test(oc->filename)) {
3739
            print_error(oc->filename, AVERROR(EINVAL));
3740
            ffmpeg_exit(1);
3741
        }
3742
    }
3743

    
3744
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3745
        /* test if it already exists to avoid loosing precious files */
3746
        if (!file_overwrite &&
3747
            (strchr(filename, ':') == NULL ||
3748
             filename[1] == ':' ||
3749
             av_strstart(filename, "file:", NULL))) {
3750
            if (avio_check(filename, 0) == 0) {
3751
                if (!using_stdin) {
3752
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3753
                    fflush(stderr);
3754
                    if (!read_yesno()) {
3755
                        fprintf(stderr, "Not overwriting - exiting\n");
3756
                        ffmpeg_exit(1);
3757
                    }
3758
                }
3759
                else {
3760
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3761
                    ffmpeg_exit(1);
3762
                }
3763
            }
3764
        }
3765

    
3766
        /* open the file */
3767
        if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3768
            print_error(filename, err);
3769
            ffmpeg_exit(1);
3770
        }
3771
    }
3772

    
3773
    memset(ap, 0, sizeof(*ap));
3774
    if (av_set_parameters(oc, ap) < 0) {
3775
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3776
                oc->filename);
3777
        ffmpeg_exit(1);
3778
    }
3779

    
3780
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3781
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3782
    oc->loop_output = loop_output;
3783
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3784

    
3785
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3786

    
3787
    av_freep(&forced_key_frames);
3788
}
3789

    
3790
/* same option as mencoder */
3791
static void opt_pass(const char *pass_str)
3792
{
3793
    int pass;
3794
    pass = atoi(pass_str);
3795
    if (pass != 1 && pass != 2) {
3796
        fprintf(stderr, "pass number can be only 1 or 2\n");
3797
        ffmpeg_exit(1);
3798
    }
3799
    do_pass = pass;
3800
}
3801

    
3802
static int64_t getutime(void)
3803
{
3804
#if HAVE_GETRUSAGE
3805
    struct rusage rusage;
3806

    
3807
    getrusage(RUSAGE_SELF, &rusage);
3808
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3809
#elif HAVE_GETPROCESSTIMES
3810
    HANDLE proc;
3811
    FILETIME c, e, k, u;
3812
    proc = GetCurrentProcess();
3813
    GetProcessTimes(proc, &c, &e, &k, &u);
3814
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3815
#else
3816
    return av_gettime();
3817
#endif
3818
}
3819

    
3820
static int64_t getmaxrss(void)
3821
{
3822
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3823
    struct rusage rusage;
3824
    getrusage(RUSAGE_SELF, &rusage);
3825
    return (int64_t)rusage.ru_maxrss * 1024;
3826
#elif HAVE_GETPROCESSMEMORYINFO
3827
    HANDLE proc;
3828
    PROCESS_MEMORY_COUNTERS memcounters;
3829
    proc = GetCurrentProcess();
3830
    memcounters.cb = sizeof(memcounters);
3831
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3832
    return memcounters.PeakPagefileUsage;
3833
#else
3834
    return 0;
3835
#endif
3836
}
3837

    
3838
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3839
{
3840
    int i;
3841
    const char *p = str;
3842
    for(i = 0;; i++) {
3843
        dest[i] = atoi(p);
3844
        if(i == 63)
3845
            break;
3846
        p = strchr(p, ',');
3847
        if(!p) {
3848
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3849
            ffmpeg_exit(1);
3850
        }
3851
        p++;
3852
    }
3853
}
3854

    
3855
static void opt_inter_matrix(const char *arg)
3856
{
3857
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3858
    parse_matrix_coeffs(inter_matrix, arg);
3859
}
3860

    
3861
static void opt_intra_matrix(const char *arg)
3862
{
3863
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3864
    parse_matrix_coeffs(intra_matrix, arg);
3865
}
3866

    
3867
static void show_usage(void)
3868
{
3869
    printf("Hyper fast Audio and Video encoder\n");
3870
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3871
    printf("\n");
3872
}
3873

    
3874
static void show_help(void)
3875
{
3876
    AVCodec *c;
3877
    AVOutputFormat *oformat = NULL;
3878

    
3879
    av_log_set_callback(log_callback_help);
3880
    show_usage();
3881
    show_help_options(options, "Main options:\n",
3882
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3883
    show_help_options(options, "\nAdvanced options:\n",
3884
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3885
                      OPT_EXPERT);
3886
    show_help_options(options, "\nVideo options:\n",
3887
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3888
                      OPT_VIDEO);
3889
    show_help_options(options, "\nAdvanced Video options:\n",
3890
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3891
                      OPT_VIDEO | OPT_EXPERT);
3892
    show_help_options(options, "\nAudio options:\n",
3893
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3894
                      OPT_AUDIO);
3895
    show_help_options(options, "\nAdvanced Audio options:\n",
3896
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3897
                      OPT_AUDIO | OPT_EXPERT);
3898
    show_help_options(options, "\nSubtitle options:\n",
3899
                      OPT_SUBTITLE | OPT_GRAB,
3900
                      OPT_SUBTITLE);
3901
    show_help_options(options, "\nAudio/Video grab options:\n",
3902
                      OPT_GRAB,
3903
                      OPT_GRAB);
3904
    printf("\n");
3905
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3906
    printf("\n");
3907

    
3908
    /* individual codec options */
3909
    c = NULL;
3910
    while ((c = av_codec_next(c))) {
3911
        if (c->priv_class) {
3912
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3913
            printf("\n");
3914
        }
3915
    }
3916

    
3917
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3918
    printf("\n");
3919

    
3920
    /* individual muxer options */
3921
    while ((oformat = av_oformat_next(oformat))) {
3922
        if (oformat->priv_class) {
3923
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3924
            printf("\n");
3925
        }
3926
    }
3927

    
3928
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3929
}
3930

    
3931
static void opt_target(const char *arg)
3932
{
3933
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3934
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3935

    
3936
    if(!strncmp(arg, "pal-", 4)) {
3937
        norm = PAL;
3938
        arg += 4;
3939
    } else if(!strncmp(arg, "ntsc-", 5)) {
3940
        norm = NTSC;
3941
        arg += 5;
3942
    } else if(!strncmp(arg, "film-", 5)) {
3943
        norm = FILM;
3944
        arg += 5;
3945
    } else {
3946
        int fr;
3947
        /* Calculate FR via float to avoid int overflow */
3948
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3949
        if(fr == 25000) {
3950
            norm = PAL;
3951
        } else if((fr == 29970) || (fr == 23976)) {
3952
            norm = NTSC;
3953
        } else {
3954
            /* Try to determine PAL/NTSC by peeking in the input files */
3955
            if(nb_input_files) {
3956
                int i, j;
3957
                for(j = 0; j < nb_input_files; j++) {
3958
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3959
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3960
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3961
                            continue;
3962
                        fr = c->time_base.den * 1000 / c->time_base.num;
3963
                        if(fr == 25000) {
3964
                            norm = PAL;
3965
                            break;
3966
                        } else if((fr == 29970) || (fr == 23976)) {
3967
                            norm = NTSC;
3968
                            break;
3969
                        }
3970
                    }
3971
                    if(norm != UNKNOWN)
3972
                        break;
3973
                }
3974
            }
3975
        }
3976
        if(verbose && norm != UNKNOWN)
3977
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3978
    }
3979

    
3980
    if(norm == UNKNOWN) {
3981
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3982
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3983
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3984
        ffmpeg_exit(1);
3985
    }
3986

    
3987
    if(!strcmp(arg, "vcd")) {
3988

    
3989
        opt_video_codec("mpeg1video");
3990
        opt_audio_codec("mp2");
3991
        opt_format("vcd");
3992

    
3993
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3994
        opt_frame_rate(NULL, frame_rates[norm]);
3995
        opt_default("g", norm == PAL ? "15" : "18");
3996

    
3997
        opt_default("b", "1150000");
3998
        opt_default("maxrate", "1150000");
3999
        opt_default("minrate", "1150000");
4000
        opt_default("bufsize", "327680"); // 40*1024*8;
4001

    
4002
        opt_default("ab", "224000");
4003
        audio_sample_rate = 44100;
4004
        audio_channels = 2;
4005

    
4006
        opt_default("packetsize", "2324");
4007
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4008

    
4009
        /* We have to offset the PTS, so that it is consistent with the SCR.
4010
           SCR starts at 36000, but the first two packs contain only padding
4011
           and the first pack from the other stream, respectively, may also have
4012
           been written before.
4013
           So the real data starts at SCR 36000+3*1200. */
4014
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4015
    } else if(!strcmp(arg, "svcd")) {
4016

    
4017
        opt_video_codec("mpeg2video");
4018
        opt_audio_codec("mp2");
4019
        opt_format("svcd");
4020

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

    
4025
        opt_default("b", "2040000");
4026
        opt_default("maxrate", "2516000");
4027
        opt_default("minrate", "0"); //1145000;
4028
        opt_default("bufsize", "1835008"); //224*1024*8;
4029
        opt_default("flags", "+scan_offset");
4030

    
4031

    
4032
        opt_default("ab", "224000");
4033
        audio_sample_rate = 44100;
4034

    
4035
        opt_default("packetsize", "2324");
4036

    
4037
    } else if(!strcmp(arg, "dvd")) {
4038

    
4039
        opt_video_codec("mpeg2video");
4040
        opt_audio_codec("ac3");
4041
        opt_format("dvd");
4042

    
4043
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4044
        opt_frame_rate(NULL, frame_rates[norm]);
4045
        opt_default("g", norm == PAL ? "15" : "18");
4046

    
4047
        opt_default("b", "6000000");
4048
        opt_default("maxrate", "9000000");
4049
        opt_default("minrate", "0"); //1500000;
4050
        opt_default("bufsize", "1835008"); //224*1024*8;
4051

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

    
4055
        opt_default("ab", "448000");
4056
        audio_sample_rate = 48000;
4057

    
4058
    } else if(!strncmp(arg, "dv", 2)) {
4059

    
4060
        opt_format("dv");
4061

    
4062
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4063
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4064
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4065
        opt_frame_rate(NULL, frame_rates[norm]);
4066

    
4067
        audio_sample_rate = 48000;
4068
        audio_channels = 2;
4069

    
4070
    } else {
4071
        fprintf(stderr, "Unknown target: %s\n", arg);
4072
        ffmpeg_exit(1);
4073
    }
4074
}
4075

    
4076
static void opt_vstats_file (const char *arg)
4077
{
4078
    av_free (vstats_filename);
4079
    vstats_filename=av_strdup (arg);
4080
}
4081

    
4082
static void opt_vstats (void)
4083
{
4084
    char filename[40];
4085
    time_t today2 = time(NULL);
4086
    struct tm *today = localtime(&today2);
4087

    
4088
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4089
             today->tm_sec);
4090
    opt_vstats_file(filename);
4091
}
4092

    
4093
static int opt_bsf(const char *opt, const char *arg)
4094
{
4095
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4096
    AVBitStreamFilterContext **bsfp;
4097

    
4098
    if(!bsfc){
4099
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4100
        ffmpeg_exit(1);
4101
    }
4102

    
4103
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4104
          *opt == 'a' ? &audio_bitstream_filters :
4105
                        &subtitle_bitstream_filters;
4106
    while(*bsfp)
4107
        bsfp= &(*bsfp)->next;
4108

    
4109
    *bsfp= bsfc;
4110

    
4111
    return 0;
4112
}
4113

    
4114
static int opt_preset(const char *opt, const char *arg)
4115
{
4116
    FILE *f=NULL;
4117
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4118
    char *codec_name = *opt == 'v' ? video_codec_name :
4119
                       *opt == 'a' ? audio_codec_name :
4120
                                     subtitle_codec_name;
4121

    
4122
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4123
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4124
        ffmpeg_exit(1);
4125
    }
4126

    
4127
    while(!feof(f)){
4128
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4129
        if(line[0] == '#' && !e)
4130
            continue;
4131
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4132
        if(e){
4133
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4134
            ffmpeg_exit(1);
4135
        }
4136
        if(!strcmp(tmp, "acodec")){
4137
            opt_audio_codec(tmp2);
4138
        }else if(!strcmp(tmp, "vcodec")){
4139
            opt_video_codec(tmp2);
4140
        }else if(!strcmp(tmp, "scodec")){
4141
            opt_subtitle_codec(tmp2);
4142
        }else if(opt_default(tmp, tmp2) < 0){
4143
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4144
            ffmpeg_exit(1);
4145
        }
4146
    }
4147

    
4148
    fclose(f);
4149

    
4150
    return 0;
4151
}
4152

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

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

    
4246
    /* audio options */
4247
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4248
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4249
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4250
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4251
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4252
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4253
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4254
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4255
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4256
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4257
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4258
    { "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" },
4259

    
4260
    /* subtitle options */
4261
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4262
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4263
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4264
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4265
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4266

    
4267
    /* grab options */
4268
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4269
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4270
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4271

    
4272
    /* muxer options */
4273
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4274
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4275

    
4276
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4277
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4278
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4279

    
4280
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4281
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4282
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4283
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4284

    
4285
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4286
    { NULL, },
4287
};
4288

    
4289
int main(int argc, char **argv)
4290
{
4291
    int64_t ti;
4292

    
4293
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4294

    
4295
    avcodec_register_all();
4296
#if CONFIG_AVDEVICE
4297
    avdevice_register_all();
4298
#endif
4299
#if CONFIG_AVFILTER
4300
    avfilter_register_all();
4301
#endif
4302
    av_register_all();
4303

    
4304
#if HAVE_ISATTY
4305
    if(isatty(STDIN_FILENO))
4306
        avio_set_interrupt_cb(decode_interrupt_cb);
4307
#endif
4308

    
4309
    init_opts();
4310

    
4311
    show_banner();
4312

    
4313
    /* parse options */
4314
    parse_options(argc, argv, options, opt_output_file);
4315

    
4316
    if(nb_output_files <= 0 && nb_input_files == 0) {
4317
        show_usage();
4318
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4319
        ffmpeg_exit(1);
4320
    }
4321

    
4322
    /* file converter / grab */
4323
    if (nb_output_files <= 0) {
4324
        fprintf(stderr, "At least one output file must be specified\n");
4325
        ffmpeg_exit(1);
4326
    }
4327

    
4328
    if (nb_input_files == 0) {
4329
        fprintf(stderr, "At least one input file must be specified\n");
4330
        ffmpeg_exit(1);
4331
    }
4332

    
4333
    ti = getutime();
4334
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4335
                  stream_maps, nb_stream_maps) < 0)
4336
        ffmpeg_exit(1);
4337
    ti = getutime() - ti;
4338
    if (do_benchmark) {
4339
        int maxrss = getmaxrss() / 1024;
4340
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4341
    }
4342

    
4343
    return ffmpeg_exit(0);
4344
}