Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 859676dd

History | View | Annotate | Download (161 KB)

1
/*
2
 * FFmpeg main
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg 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
 * FFmpeg 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 FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

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

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

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

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

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

    
72
#if HAVE_TERMIOS_H
73
#include <fcntl.h>
74
#include <sys/ioctl.h>
75
#include <sys/time.h>
76
#include <termios.h>
77
#elif HAVE_KBHIT
78
#include <conio.h>
79
#endif
80
#include <time.h>
81

    
82
#include "cmdutils.h"
83

    
84
#include "libavutil/avassert.h"
85

    
86
const char program_name[] = "FFmpeg";
87
const int program_birth_year = 2000;
88

    
89
/* select an input stream for an output stream */
90
typedef struct AVStreamMap {
91
    int file_index;
92
    int stream_index;
93
    int sync_file_index;
94
    int sync_stream_index;
95
} AVStreamMap;
96

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

    
106
typedef struct AVChapterMap {
107
    int in_file;
108
    int out_file;
109
} AVChapterMap;
110

    
111
static const OptionDef options[];
112

    
113
#define MAX_FILES 100
114
#if !FF_API_MAX_STREAMS
115
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
116
#endif
117

    
118
static const char *last_asked_format = NULL;
119
static AVFormatContext *input_files[MAX_FILES];
120
static int64_t input_files_ts_offset[MAX_FILES];
121
static double *input_files_ts_scale[MAX_FILES] = {NULL};
122
static AVCodec **input_codecs = NULL;
123
static int nb_input_files = 0;
124
static int nb_input_codecs = 0;
125
static int nb_input_files_ts_scale[MAX_FILES] = {0};
126

    
127
static AVFormatContext *output_files[MAX_FILES];
128
static AVCodec **output_codecs = NULL;
129
static int nb_output_files = 0;
130
static int nb_output_codecs = 0;
131

    
132
static AVStreamMap *stream_maps = NULL;
133
static int nb_stream_maps;
134

    
135
/* first item specifies output metadata, second is input */
136
static AVMetaDataMap (*meta_data_maps)[2] = NULL;
137
static int nb_meta_data_maps;
138
static int metadata_global_autocopy   = 1;
139
static int metadata_streams_autocopy  = 1;
140
static int metadata_chapters_autocopy = 1;
141

    
142
static AVChapterMap *chapter_maps = NULL;
143
static int nb_chapter_maps;
144

    
145
/* indexed by output file stream index */
146
static int *streamid_map = NULL;
147
static int nb_streamid_map = 0;
148

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

    
179
static int intra_only = 0;
180
static int audio_sample_rate = 44100;
181
static int64_t channel_layout = 0;
182
#define QSCALE_NONE -99999
183
static float audio_qscale = QSCALE_NONE;
184
static int audio_disable = 0;
185
static int audio_channels = 1;
186
static char  *audio_codec_name = NULL;
187
static unsigned int audio_codec_tag = 0;
188
static char *audio_language = NULL;
189

    
190
static int subtitle_disable = 0;
191
static char *subtitle_codec_name = NULL;
192
static char *subtitle_language = NULL;
193
static unsigned int subtitle_codec_tag = 0;
194

    
195
static float mux_preload= 0.5;
196
static float mux_max_delay= 0.7;
197

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

    
225
static int rate_emu = 0;
226

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

    
230
static int audio_volume = 256;
231

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

    
247
static float dts_delta_threshold = 10;
248

    
249
static int64_t timer_start;
250

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

    
255
static short *samples;
256

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

    
261
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
262

    
263
struct AVInputStream;
264

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

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

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

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

    
306
#if CONFIG_AVFILTER
307
    AVFilterContext *output_video_filter;
308
    AVFilterContext *input_video_filter;
309
    AVFilterBufferRef *picref;
310
    char *avfilter;
311
    AVFilterGraph *graph;
312
#endif
313
} AVOutputStream;
314

    
315
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
316
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
317

    
318
typedef struct AVInputStream {
319
    int file_index;
320
    int index;
321
    AVStream *st;
322
    int discard;             /* true if stream data should be discarded */
323
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
324
    int64_t sample_index;      /* current sample */
325

    
326
    int64_t       start;     /* time when read started */
327
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
328
                                is not defined */
329
    int64_t       pts;       /* current pts */
330
    int is_start;            /* is 1 at the start and after a discontinuity */
331
    int showed_multi_packet_warning;
332
    int is_past_recording_time;
333
#if CONFIG_AVFILTER
334
    AVFrame *filter_frame;
335
    int has_filter_frame;
336
#endif
337
} AVInputStream;
338

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

    
346
#if HAVE_TERMIOS_H
347

    
348
/* init terminal so that we can grab keys */
349
static struct termios oldtty;
350
#endif
351

    
352
#if CONFIG_AVFILTER
353

    
354
static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
355
{
356
    AVFilterContext *last_filter, *filter;
357
    /** filter graph containing all filters including input & output */
358
    AVCodecContext *codec = ost->st->codec;
359
    AVCodecContext *icodec = ist->st->codec;
360
    FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
361
    AVRational sample_aspect_ratio;
362
    char args[255];
363
    int ret;
364

    
365
    ost->graph = avfilter_graph_alloc();
366

    
367
    if (ist->st->sample_aspect_ratio.num){
368
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
369
    }else
370
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
371

    
372
    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
373
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
374
             sample_aspect_ratio.num, sample_aspect_ratio.den);
375

    
376
    ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
377
                                       "src", args, NULL, ost->graph);
378
    if (ret < 0)
379
        return ret;
380
    ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
381
                                       "out", NULL, &ffsink_ctx, ost->graph);
382
    if (ret < 0)
383
        return ret;
384
    last_filter = ost->input_video_filter;
385

    
386
    if (codec->width  != icodec->width || codec->height != icodec->height) {
387
        snprintf(args, 255, "%d:%d:flags=0x%X",
388
                 codec->width,
389
                 codec->height,
390
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
391
        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
392
                                                NULL, args, NULL, ost->graph)) < 0)
393
            return ret;
394
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
395
            return ret;
396
        last_filter = filter;
397
    }
398

    
399
    snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
400
    ost->graph->scale_sws_opts = av_strdup(args);
401

    
402
    if (ost->avfilter) {
403
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
404
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
405

    
406
        outputs->name    = av_strdup("in");
407
        outputs->filter_ctx = last_filter;
408
        outputs->pad_idx = 0;
409
        outputs->next    = NULL;
410

    
411
        inputs->name    = av_strdup("out");
412
        inputs->filter_ctx = ost->output_video_filter;
413
        inputs->pad_idx = 0;
414
        inputs->next    = NULL;
415

    
416
        if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
417
            return ret;
418
        av_freep(&ost->avfilter);
419
    } else {
420
        if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
421
            return ret;
422
    }
423

    
424
    if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
425
        return ret;
426

    
427
    codec->width  = ost->output_video_filter->inputs[0]->w;
428
    codec->height = ost->output_video_filter->inputs[0]->h;
429
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
430
        ost->output_video_filter->inputs[0]->sample_aspect_ratio;
431

    
432
    return 0;
433
}
434
#endif /* CONFIG_AVFILTER */
435

    
436
static void term_exit(void)
437
{
438
    av_log(NULL, AV_LOG_QUIET, "");
439
#if HAVE_TERMIOS_H
440
    tcsetattr (0, TCSANOW, &oldtty);
441
#endif
442
}
443

    
444
static volatile int received_sigterm = 0;
445

    
446
static void
447
sigterm_handler(int sig)
448
{
449
    received_sigterm = sig;
450
    q_pressed++;
451
    term_exit();
452
}
453

    
454
static void term_init(void)
455
{
456
#if HAVE_TERMIOS_H
457
    struct termios tty;
458

    
459
    tcgetattr (0, &tty);
460
    oldtty = tty;
461
    atexit(term_exit);
462

    
463
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
464
                          |INLCR|IGNCR|ICRNL|IXON);
465
    tty.c_oflag |= OPOST;
466
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
467
    tty.c_cflag &= ~(CSIZE|PARENB);
468
    tty.c_cflag |= CS8;
469
    tty.c_cc[VMIN] = 1;
470
    tty.c_cc[VTIME] = 0;
471

    
472
    tcsetattr (0, TCSANOW, &tty);
473
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
474
#endif
475

    
476
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
477
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
478
#ifdef SIGXCPU
479
    signal(SIGXCPU, sigterm_handler);
480
#endif
481
}
482

    
483
/* read a key without blocking */
484
static int read_key(void)
485
{
486
#if HAVE_TERMIOS_H
487
    int n = 1;
488
    unsigned char ch;
489
    struct timeval tv;
490
    fd_set rfds;
491

    
492
    FD_ZERO(&rfds);
493
    FD_SET(0, &rfds);
494
    tv.tv_sec = 0;
495
    tv.tv_usec = 0;
496
    n = select(1, &rfds, NULL, NULL, &tv);
497
    if (n > 0) {
498
        n = read(0, &ch, 1);
499
        if (n == 1)
500
            return ch;
501

    
502
        return n;
503
    }
504
#elif HAVE_KBHIT
505
    if(kbhit())
506
        return(getch());
507
#endif
508
    return -1;
509
}
510

    
511
static int decode_interrupt_cb(void)
512
{
513
    q_pressed += read_key() == 'q';
514
    return q_pressed > 1;
515
}
516

    
517
static int ffmpeg_exit(int ret)
518
{
519
    int i;
520

    
521
    /* close files */
522
    for(i=0;i<nb_output_files;i++) {
523
        AVFormatContext *s = output_files[i];
524
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
525
            avio_close(s->pb);
526
        avformat_free_context(s);
527
        av_free(output_streams_for_file[i]);
528
    }
529
    for(i=0;i<nb_input_files;i++) {
530
        av_close_input_file(input_files[i]);
531
        av_free(input_files_ts_scale[i]);
532
    }
533

    
534
    av_free(intra_matrix);
535
    av_free(inter_matrix);
536

    
537
    if (vstats_file)
538
        fclose(vstats_file);
539
    av_free(vstats_filename);
540

    
541
    av_free(streamid_map);
542
    av_free(input_codecs);
543
    av_free(output_codecs);
544
    av_free(stream_maps);
545
    av_free(meta_data_maps);
546

    
547
    av_free(video_codec_name);
548
    av_free(audio_codec_name);
549
    av_free(subtitle_codec_name);
550

    
551
    av_free(video_standard);
552

    
553
    uninit_opts();
554
    av_free(audio_buf);
555
    av_free(audio_out);
556
    allocated_audio_buf_size= allocated_audio_out_size= 0;
557
    av_free(samples);
558

    
559
#if CONFIG_AVFILTER
560
    avfilter_uninit();
561
#endif
562

    
563
    if (received_sigterm) {
564
        fprintf(stderr,
565
            "Received signal %d: terminating.\n",
566
            (int) received_sigterm);
567
        exit (255);
568
    }
569

    
570
    exit(ret); /* not all OS-es handle main() return value */
571
    return ret;
572
}
573

    
574
/* similar to ff_dynarray_add() and av_fast_realloc() */
575
static void *grow_array(void *array, int elem_size, int *size, int new_size)
576
{
577
    if (new_size >= INT_MAX / elem_size) {
578
        fprintf(stderr, "Array too big.\n");
579
        ffmpeg_exit(1);
580
    }
581
    if (*size < new_size) {
582
        uint8_t *tmp = av_realloc(array, new_size*elem_size);
583
        if (!tmp) {
584
            fprintf(stderr, "Could not alloc buffer.\n");
585
            ffmpeg_exit(1);
586
        }
587
        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
588
        *size = new_size;
589
        return tmp;
590
    }
591
    return array;
592
}
593

    
594
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
595
{
596
    if(codec && codec->sample_fmts){
597
        const enum AVSampleFormat *p= codec->sample_fmts;
598
        for(; *p!=-1; p++){
599
            if(*p == st->codec->sample_fmt)
600
                break;
601
        }
602
        if (*p == -1) {
603
            av_log(NULL, AV_LOG_WARNING,
604
                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
605
                   av_get_sample_fmt_name(st->codec->sample_fmt),
606
                   codec->name,
607
                   av_get_sample_fmt_name(codec->sample_fmts[0]));
608
            st->codec->sample_fmt = codec->sample_fmts[0];
609
        }
610
    }
611
}
612

    
613
static void choose_sample_rate(AVStream *st, AVCodec *codec)
614
{
615
    if(codec && codec->supported_samplerates){
616
        const int *p= codec->supported_samplerates;
617
        int best=0;
618
        int best_dist=INT_MAX;
619
        for(; *p; p++){
620
            int dist= abs(st->codec->sample_rate - *p);
621
            if(dist < best_dist){
622
                best_dist= dist;
623
                best= *p;
624
            }
625
        }
626
        if(best_dist){
627
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
628
        }
629
        st->codec->sample_rate= best;
630
    }
631
}
632

    
633
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
634
{
635
    if(codec && codec->pix_fmts){
636
        const enum PixelFormat *p= codec->pix_fmts;
637
        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
638
            if(st->codec->codec_id==CODEC_ID_MJPEG){
639
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
640
            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
641
                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};
642
            }
643
        }
644
        for(; *p!=-1; p++){
645
            if(*p == st->codec->pix_fmt)
646
                break;
647
        }
648
        if (*p == -1) {
649
            av_log(NULL, AV_LOG_WARNING,
650
                   "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
651
                   av_pix_fmt_descriptors[st->codec->pix_fmt].name,
652
                   codec->name,
653
                   av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
654
            st->codec->pix_fmt = codec->pix_fmts[0];
655
        }
656
    }
657
}
658

    
659
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
660
{
661
    int idx = oc->nb_streams - 1;
662
    AVOutputStream *ost;
663

    
664
    output_streams_for_file[file_idx] =
665
        grow_array(output_streams_for_file[file_idx],
666
                   sizeof(*output_streams_for_file[file_idx]),
667
                   &nb_output_streams_for_file[file_idx],
668
                   oc->nb_streams);
669
    ost = output_streams_for_file[file_idx][idx] =
670
        av_mallocz(sizeof(AVOutputStream));
671
    if (!ost) {
672
        fprintf(stderr, "Could not alloc output stream\n");
673
        ffmpeg_exit(1);
674
    }
675
    ost->file_index = file_idx;
676
    ost->index = idx;
677
    return ost;
678
}
679

    
680
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
681
{
682
    int i, err;
683
    AVFormatContext *ic;
684
    int nopts = 0;
685

    
686
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
687
    if (err < 0)
688
        return err;
689
    /* copy stream format */
690
    s->nb_streams = 0;
691
    for(i=0;i<ic->nb_streams;i++) {
692
        AVStream *st;
693
        AVCodec *codec;
694

    
695
        s->nb_streams++;
696

    
697
        // FIXME: a more elegant solution is needed
698
        st = av_mallocz(sizeof(AVStream));
699
        memcpy(st, ic->streams[i], sizeof(AVStream));
700
        st->codec = avcodec_alloc_context();
701
        if (!st->codec) {
702
            print_error(filename, AVERROR(ENOMEM));
703
            ffmpeg_exit(1);
704
        }
705
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
706
        s->streams[i] = st;
707

    
708
        codec = avcodec_find_encoder(st->codec->codec_id);
709
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
710
            if (audio_stream_copy) {
711
                st->stream_copy = 1;
712
            } else
713
                choose_sample_fmt(st, codec);
714
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
715
            if (video_stream_copy) {
716
                st->stream_copy = 1;
717
            } else
718
                choose_pixel_fmt(st, codec);
719
        }
720

    
721
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
722
            nopts = 1;
723

    
724
        new_output_stream(s, nb_output_files);
725
    }
726

    
727
    if (!nopts)
728
        s->timestamp = av_gettime();
729

    
730
    av_close_input_file(ic);
731
    return 0;
732
}
733

    
734
static double
735
get_sync_ipts(const AVOutputStream *ost)
736
{
737
    const AVInputStream *ist = ost->sync_ist;
738
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
739
}
740

    
741
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
742
    int ret;
743

    
744
    while(bsfc){
745
        AVPacket new_pkt= *pkt;
746
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
747
                                          &new_pkt.data, &new_pkt.size,
748
                                          pkt->data, pkt->size,
749
                                          pkt->flags & AV_PKT_FLAG_KEY);
750
        if(a>0){
751
            av_free_packet(pkt);
752
            new_pkt.destruct= av_destruct_packet;
753
        } else if(a<0){
754
            fprintf(stderr, "%s failed for stream %d, codec %s",
755
                    bsfc->filter->name, pkt->stream_index,
756
                    avctx->codec ? avctx->codec->name : "copy");
757
            print_error("", a);
758
            if (exit_on_error)
759
                ffmpeg_exit(1);
760
        }
761
        *pkt= new_pkt;
762

    
763
        bsfc= bsfc->next;
764
    }
765

    
766
    ret= av_interleaved_write_frame(s, pkt);
767
    if(ret < 0){
768
        print_error("av_interleaved_write_frame()", ret);
769
        ffmpeg_exit(1);
770
    }
771
}
772

    
773
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
774

    
775
static void do_audio_out(AVFormatContext *s,
776
                         AVOutputStream *ost,
777
                         AVInputStream *ist,
778
                         unsigned char *buf, int size)
779
{
780
    uint8_t *buftmp;
781
    int64_t audio_out_size, audio_buf_size;
782
    int64_t allocated_for_size= size;
783

    
784
    int size_out, frame_bytes, ret, resample_changed;
785
    AVCodecContext *enc= ost->st->codec;
786
    AVCodecContext *dec= ist->st->codec;
787
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
788
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
789
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
790

    
791
need_realloc:
792
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
793
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
794
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
795
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
796
    audio_buf_size*= osize*enc->channels;
797

    
798
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
799
    if(coded_bps > 8*osize)
800
        audio_out_size= audio_out_size * coded_bps / (8*osize);
801
    audio_out_size += FF_MIN_BUFFER_SIZE;
802

    
803
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
804
        fprintf(stderr, "Buffer sizes too large\n");
805
        ffmpeg_exit(1);
806
    }
807

    
808
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
809
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
810
    if (!audio_buf || !audio_out){
811
        fprintf(stderr, "Out of memory in do_audio_out\n");
812
        ffmpeg_exit(1);
813
    }
814

    
815
    if (enc->channels != dec->channels)
816
        ost->audio_resample = 1;
817

    
818
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
819
                       ost->resample_channels    != dec->channels   ||
820
                       ost->resample_sample_rate != dec->sample_rate;
821

    
822
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
823
        if (resample_changed) {
824
            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",
825
                   ist->file_index, ist->index,
826
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
827
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
828
            ost->resample_sample_fmt  = dec->sample_fmt;
829
            ost->resample_channels    = dec->channels;
830
            ost->resample_sample_rate = dec->sample_rate;
831
            if (ost->resample)
832
                audio_resample_close(ost->resample);
833
        }
834
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
835
        if (audio_sync_method <= 1 &&
836
            ost->resample_sample_fmt  == enc->sample_fmt &&
837
            ost->resample_channels    == enc->channels   &&
838
            ost->resample_sample_rate == enc->sample_rate) {
839
            ost->resample = NULL;
840
            ost->audio_resample = 0;
841
        } else {
842
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
843
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
844
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
845
                                                   enc->sample_rate, dec->sample_rate,
846
                                                   enc->sample_fmt,  dec->sample_fmt,
847
                                                   16, 10, 0, 0.8);
848
            if (!ost->resample) {
849
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
850
                        dec->channels, dec->sample_rate,
851
                        enc->channels, enc->sample_rate);
852
                ffmpeg_exit(1);
853
            }
854
        }
855
    }
856

    
857
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
858
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
859
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
860
        if (ost->reformat_ctx)
861
            av_audio_convert_free(ost->reformat_ctx);
862
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
863
                                                   dec->sample_fmt, 1, NULL, 0);
864
        if (!ost->reformat_ctx) {
865
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
866
                av_get_sample_fmt_name(dec->sample_fmt),
867
                av_get_sample_fmt_name(enc->sample_fmt));
868
            ffmpeg_exit(1);
869
        }
870
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
871
    }
872

    
873
    if(audio_sync_method){
874
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
875
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
876
        double idelta= delta*dec->sample_rate / enc->sample_rate;
877
        int byte_delta= ((int)idelta)*2*dec->channels;
878

    
879
        //FIXME resample delay
880
        if(fabs(delta) > 50){
881
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
882
                if(byte_delta < 0){
883
                    byte_delta= FFMAX(byte_delta, -size);
884
                    size += byte_delta;
885
                    buf  -= byte_delta;
886
                    if(verbose > 2)
887
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
888
                    if(!size)
889
                        return;
890
                    ist->is_start=0;
891
                }else{
892
                    static uint8_t *input_tmp= NULL;
893
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
894

    
895
                    if(byte_delta > allocated_for_size - size){
896
                        allocated_for_size= byte_delta + (int64_t)size;
897
                        goto need_realloc;
898
                    }
899
                    ist->is_start=0;
900

    
901
                    memset(input_tmp, 0, byte_delta);
902
                    memcpy(input_tmp + byte_delta, buf, size);
903
                    buf= input_tmp;
904
                    size += byte_delta;
905
                    if(verbose > 2)
906
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
907
                }
908
            }else if(audio_sync_method>1){
909
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
910
                av_assert0(ost->audio_resample);
911
                if(verbose > 2)
912
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
913
//                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));
914
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
915
            }
916
        }
917
    }else
918
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
919
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
920

    
921
    if (ost->audio_resample) {
922
        buftmp = audio_buf;
923
        size_out = audio_resample(ost->resample,
924
                                  (short *)buftmp, (short *)buf,
925
                                  size / (dec->channels * isize));
926
        size_out = size_out * enc->channels * osize;
927
    } else {
928
        buftmp = buf;
929
        size_out = size;
930
    }
931

    
932
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
933
        const void *ibuf[6]= {buftmp};
934
        void *obuf[6]= {audio_buf};
935
        int istride[6]= {isize};
936
        int ostride[6]= {osize};
937
        int len= size_out/istride[0];
938
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
939
            printf("av_audio_convert() failed\n");
940
            if (exit_on_error)
941
                ffmpeg_exit(1);
942
            return;
943
        }
944
        buftmp = audio_buf;
945
        size_out = len*osize;
946
    }
947

    
948
    /* now encode as many frames as possible */
949
    if (enc->frame_size > 1) {
950
        /* output resampled raw samples */
951
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
952
            fprintf(stderr, "av_fifo_realloc2() failed\n");
953
            ffmpeg_exit(1);
954
        }
955
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
956

    
957
        frame_bytes = enc->frame_size * osize * enc->channels;
958

    
959
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
960
            AVPacket pkt;
961
            av_init_packet(&pkt);
962

    
963
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
964

    
965
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
966

    
967
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
968
                                       (short *)audio_buf);
969
            if (ret < 0) {
970
                fprintf(stderr, "Audio encoding failed\n");
971
                ffmpeg_exit(1);
972
            }
973
            audio_size += ret;
974
            pkt.stream_index= ost->index;
975
            pkt.data= audio_out;
976
            pkt.size= ret;
977
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
978
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
979
            pkt.flags |= AV_PKT_FLAG_KEY;
980
            write_frame(s, &pkt, enc, ost->bitstream_filters);
981

    
982
            ost->sync_opts += enc->frame_size;
983
        }
984
    } else {
985
        AVPacket pkt;
986
        av_init_packet(&pkt);
987

    
988
        ost->sync_opts += size_out / (osize * enc->channels);
989

    
990
        /* output a pcm frame */
991
        /* determine the size of the coded buffer */
992
        size_out /= osize;
993
        if (coded_bps)
994
            size_out = size_out*coded_bps/8;
995

    
996
        if(size_out > audio_out_size){
997
            fprintf(stderr, "Internal error, buffer size too small\n");
998
            ffmpeg_exit(1);
999
        }
1000

    
1001
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1002
        ret = avcodec_encode_audio(enc, audio_out, size_out,
1003
                                   (short *)buftmp);
1004
        if (ret < 0) {
1005
            fprintf(stderr, "Audio encoding failed\n");
1006
            ffmpeg_exit(1);
1007
        }
1008
        audio_size += ret;
1009
        pkt.stream_index= ost->index;
1010
        pkt.data= audio_out;
1011
        pkt.size= ret;
1012
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1013
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1014
        pkt.flags |= AV_PKT_FLAG_KEY;
1015
        write_frame(s, &pkt, enc, ost->bitstream_filters);
1016
    }
1017
}
1018

    
1019
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1020
{
1021
    AVCodecContext *dec;
1022
    AVPicture *picture2;
1023
    AVPicture picture_tmp;
1024
    uint8_t *buf = 0;
1025

    
1026
    dec = ist->st->codec;
1027

    
1028
    /* deinterlace : must be done before any resize */
1029
    if (do_deinterlace) {
1030
        int size;
1031

    
1032
        /* create temporary picture */
1033
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1034
        buf = av_malloc(size);
1035
        if (!buf)
1036
            return;
1037

    
1038
        picture2 = &picture_tmp;
1039
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1040

    
1041
        if(avpicture_deinterlace(picture2, picture,
1042
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1043
            /* if error, do not deinterlace */
1044
            fprintf(stderr, "Deinterlacing failed\n");
1045
            av_free(buf);
1046
            buf = NULL;
1047
            picture2 = picture;
1048
        }
1049
    } else {
1050
        picture2 = picture;
1051
    }
1052

    
1053
    if (picture != picture2)
1054
        *picture = *picture2;
1055
    *bufp = buf;
1056
}
1057

    
1058
/* we begin to correct av delay at this threshold */
1059
#define AV_DELAY_MAX 0.100
1060

    
1061
static void do_subtitle_out(AVFormatContext *s,
1062
                            AVOutputStream *ost,
1063
                            AVInputStream *ist,
1064
                            AVSubtitle *sub,
1065
                            int64_t pts)
1066
{
1067
    static uint8_t *subtitle_out = NULL;
1068
    int subtitle_out_max_size = 1024 * 1024;
1069
    int subtitle_out_size, nb, i;
1070
    AVCodecContext *enc;
1071
    AVPacket pkt;
1072

    
1073
    if (pts == AV_NOPTS_VALUE) {
1074
        fprintf(stderr, "Subtitle packets must have a pts\n");
1075
        if (exit_on_error)
1076
            ffmpeg_exit(1);
1077
        return;
1078
    }
1079

    
1080
    enc = ost->st->codec;
1081

    
1082
    if (!subtitle_out) {
1083
        subtitle_out = av_malloc(subtitle_out_max_size);
1084
    }
1085

    
1086
    /* Note: DVB subtitle need one packet to draw them and one other
1087
       packet to clear them */
1088
    /* XXX: signal it in the codec context ? */
1089
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1090
        nb = 2;
1091
    else
1092
        nb = 1;
1093

    
1094
    for(i = 0; i < nb; i++) {
1095
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1096
        // start_display_time is required to be 0
1097
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1098
        sub->end_display_time -= sub->start_display_time;
1099
        sub->start_display_time = 0;
1100
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1101
                                                    subtitle_out_max_size, sub);
1102
        if (subtitle_out_size < 0) {
1103
            fprintf(stderr, "Subtitle encoding failed\n");
1104
            ffmpeg_exit(1);
1105
        }
1106

    
1107
        av_init_packet(&pkt);
1108
        pkt.stream_index = ost->index;
1109
        pkt.data = subtitle_out;
1110
        pkt.size = subtitle_out_size;
1111
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1112
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1113
            /* XXX: the pts correction is handled here. Maybe handling
1114
               it in the codec would be better */
1115
            if (i == 0)
1116
                pkt.pts += 90 * sub->start_display_time;
1117
            else
1118
                pkt.pts += 90 * sub->end_display_time;
1119
        }
1120
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1121
    }
1122
}
1123

    
1124
static int bit_buffer_size= 1024*256;
1125
static uint8_t *bit_buffer= NULL;
1126

    
1127
static void do_video_out(AVFormatContext *s,
1128
                         AVOutputStream *ost,
1129
                         AVInputStream *ist,
1130
                         AVFrame *in_picture,
1131
                         int *frame_size)
1132
{
1133
    int nb_frames, i, ret;
1134
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1135
    AVCodecContext *enc, *dec;
1136
    double sync_ipts;
1137

    
1138
    enc = ost->st->codec;
1139
    dec = ist->st->codec;
1140

    
1141
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1142

    
1143
    /* by default, we output a single frame */
1144
    nb_frames = 1;
1145

    
1146
    *frame_size = 0;
1147

    
1148
    if(video_sync_method){
1149
        double vdelta = sync_ipts - ost->sync_opts;
1150
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1151
        if (vdelta < -1.1)
1152
            nb_frames = 0;
1153
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1154
            if(vdelta<=-0.6){
1155
                nb_frames=0;
1156
            }else if(vdelta>0.6)
1157
                ost->sync_opts= lrintf(sync_ipts);
1158
        }else if (vdelta > 1.1)
1159
            nb_frames = lrintf(vdelta);
1160
//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);
1161
        if (nb_frames == 0){
1162
            ++nb_frames_drop;
1163
            if (verbose>2)
1164
                fprintf(stderr, "*** drop!\n");
1165
        }else if (nb_frames > 1) {
1166
            nb_frames_dup += nb_frames - 1;
1167
            if (verbose>2)
1168
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1169
        }
1170
    }else
1171
        ost->sync_opts= lrintf(sync_ipts);
1172

    
1173
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1174
    if (nb_frames <= 0)
1175
        return;
1176

    
1177
    formatted_picture = in_picture;
1178
    final_picture = formatted_picture;
1179
    padding_src = formatted_picture;
1180
    resampling_dst = &ost->pict_tmp;
1181

    
1182
    if (   ost->resample_height != ist->st->codec->height
1183
        || ost->resample_width  != ist->st->codec->width
1184
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1185

    
1186
        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));
1187
        if(!ost->video_resample)
1188
            ffmpeg_exit(1);
1189
    }
1190

    
1191
#if !CONFIG_AVFILTER
1192
    if (ost->video_resample) {
1193
        padding_src = NULL;
1194
        final_picture = &ost->pict_tmp;
1195
        if(  ost->resample_height != ist->st->codec->height
1196
          || ost->resample_width  != ist->st->codec->width
1197
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1198

    
1199
            /* initialize a new scaler context */
1200
            sws_freeContext(ost->img_resample_ctx);
1201
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1202
            ost->img_resample_ctx = sws_getContext(
1203
                ist->st->codec->width,
1204
                ist->st->codec->height,
1205
                ist->st->codec->pix_fmt,
1206
                ost->st->codec->width,
1207
                ost->st->codec->height,
1208
                ost->st->codec->pix_fmt,
1209
                sws_flags, NULL, NULL, NULL);
1210
            if (ost->img_resample_ctx == NULL) {
1211
                fprintf(stderr, "Cannot get resampling context\n");
1212
                ffmpeg_exit(1);
1213
            }
1214
        }
1215
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1216
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1217
    }
1218
#endif
1219

    
1220
    /* duplicates frame if needed */
1221
    for(i=0;i<nb_frames;i++) {
1222
        AVPacket pkt;
1223
        av_init_packet(&pkt);
1224
        pkt.stream_index= ost->index;
1225

    
1226
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1227
            /* raw pictures are written as AVPicture structure to
1228
               avoid any copies. We support temorarily the older
1229
               method. */
1230
            AVFrame* old_frame = enc->coded_frame;
1231
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1232
            pkt.data= (uint8_t *)final_picture;
1233
            pkt.size=  sizeof(AVPicture);
1234
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1235
            pkt.flags |= AV_PKT_FLAG_KEY;
1236

    
1237
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1238
            enc->coded_frame = old_frame;
1239
        } else {
1240
            AVFrame big_picture;
1241

    
1242
            big_picture= *final_picture;
1243
            /* better than nothing: use input picture interlaced
1244
               settings */
1245
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1246
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1247
                if(top_field_first == -1)
1248
                    big_picture.top_field_first = in_picture->top_field_first;
1249
                else
1250
                    big_picture.top_field_first = top_field_first;
1251
            }
1252

    
1253
            /* handles sameq here. This is not correct because it may
1254
               not be a global option */
1255
            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1256
            if(!me_threshold)
1257
                big_picture.pict_type = 0;
1258
//            big_picture.pts = AV_NOPTS_VALUE;
1259
            big_picture.pts= ost->sync_opts;
1260
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1261
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1262
            if (ost->forced_kf_index < ost->forced_kf_count &&
1263
                big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1264
                big_picture.pict_type = FF_I_TYPE;
1265
                ost->forced_kf_index++;
1266
            }
1267
            ret = avcodec_encode_video(enc,
1268
                                       bit_buffer, bit_buffer_size,
1269
                                       &big_picture);
1270
            if (ret < 0) {
1271
                fprintf(stderr, "Video encoding failed\n");
1272
                ffmpeg_exit(1);
1273
            }
1274

    
1275
            if(ret>0){
1276
                pkt.data= bit_buffer;
1277
                pkt.size= ret;
1278
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1279
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1280
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1281
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1282
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1283

    
1284
                if(enc->coded_frame->key_frame)
1285
                    pkt.flags |= AV_PKT_FLAG_KEY;
1286
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1287
                *frame_size = ret;
1288
                video_size += ret;
1289
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1290
                //        enc->frame_number-1, ret, enc->pict_type);
1291
                /* if two pass, output log */
1292
                if (ost->logfile && enc->stats_out) {
1293
                    fprintf(ost->logfile, "%s", enc->stats_out);
1294
                }
1295
            }
1296
        }
1297
        ost->sync_opts++;
1298
        ost->frame_number++;
1299
    }
1300
}
1301

    
1302
static double psnr(double d){
1303
    return -10.0*log(d)/log(10.0);
1304
}
1305

    
1306
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1307
                           int frame_size)
1308
{
1309
    AVCodecContext *enc;
1310
    int frame_number;
1311
    double ti1, bitrate, avg_bitrate;
1312

    
1313
    /* this is executed just the first time do_video_stats is called */
1314
    if (!vstats_file) {
1315
        vstats_file = fopen(vstats_filename, "w");
1316
        if (!vstats_file) {
1317
            perror("fopen");
1318
            ffmpeg_exit(1);
1319
        }
1320
    }
1321

    
1322
    enc = ost->st->codec;
1323
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1324
        frame_number = ost->frame_number;
1325
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1326
        if (enc->flags&CODEC_FLAG_PSNR)
1327
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1328

    
1329
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1330
        /* compute pts value */
1331
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1332
        if (ti1 < 0.01)
1333
            ti1 = 0.01;
1334

    
1335
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1336
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1337
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1338
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1339
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1340
    }
1341
}
1342

    
1343
static void print_report(AVFormatContext **output_files,
1344
                         AVOutputStream **ost_table, int nb_ostreams,
1345
                         int is_last_report)
1346
{
1347
    char buf[1024];
1348
    AVOutputStream *ost;
1349
    AVFormatContext *oc;
1350
    int64_t total_size;
1351
    AVCodecContext *enc;
1352
    int frame_number, vid, i;
1353
    double bitrate, ti1, pts;
1354
    static int64_t last_time = -1;
1355
    static int qp_histogram[52];
1356

    
1357
    if (!is_last_report) {
1358
        int64_t cur_time;
1359
        /* display the report every 0.5 seconds */
1360
        cur_time = av_gettime();
1361
        if (last_time == -1) {
1362
            last_time = cur_time;
1363
            return;
1364
        }
1365
        if ((cur_time - last_time) < 500000)
1366
            return;
1367
        last_time = cur_time;
1368
    }
1369

    
1370

    
1371
    oc = output_files[0];
1372

    
1373
    total_size = avio_size(oc->pb);
1374
    if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1375
        total_size= avio_tell(oc->pb);
1376

    
1377
    buf[0] = '\0';
1378
    ti1 = 1e10;
1379
    vid = 0;
1380
    for(i=0;i<nb_ostreams;i++) {
1381
        ost = ost_table[i];
1382
        enc = ost->st->codec;
1383
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1384
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1385
                     !ost->st->stream_copy ?
1386
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1387
        }
1388
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1389
            float t = (av_gettime()-timer_start) / 1000000.0;
1390

    
1391
            frame_number = ost->frame_number;
1392
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1393
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1394
                     !ost->st->stream_copy ?
1395
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1396
            if(is_last_report)
1397
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1398
            if(qp_hist){
1399
                int j;
1400
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1401
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1402
                    qp_histogram[qp]++;
1403
                for(j=0; j<32; j++)
1404
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1405
            }
1406
            if (enc->flags&CODEC_FLAG_PSNR){
1407
                int j;
1408
                double error, error_sum=0;
1409
                double scale, scale_sum=0;
1410
                char type[3]= {'Y','U','V'};
1411
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1412
                for(j=0; j<3; j++){
1413
                    if(is_last_report){
1414
                        error= enc->error[j];
1415
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1416
                    }else{
1417
                        error= enc->coded_frame->error[j];
1418
                        scale= enc->width*enc->height*255.0*255.0;
1419
                    }
1420
                    if(j) scale/=4;
1421
                    error_sum += error;
1422
                    scale_sum += scale;
1423
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1424
                }
1425
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1426
            }
1427
            vid = 1;
1428
        }
1429
        /* compute min output value */
1430
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1431
        if ((pts < ti1) && (pts > 0))
1432
            ti1 = pts;
1433
    }
1434
    if (ti1 < 0.01)
1435
        ti1 = 0.01;
1436

    
1437
    if (verbose || is_last_report) {
1438
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1439

    
1440
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1441
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1442
            (double)total_size / 1024, ti1, bitrate);
1443

    
1444
        if (nb_frames_dup || nb_frames_drop)
1445
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1446
                  nb_frames_dup, nb_frames_drop);
1447

    
1448
        if (verbose >= 0)
1449
            fprintf(stderr, "%s    \r", buf);
1450

    
1451
        fflush(stderr);
1452
    }
1453

    
1454
    if (is_last_report && verbose >= 0){
1455
        int64_t raw= audio_size + video_size + extra_size;
1456
        fprintf(stderr, "\n");
1457
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1458
                video_size/1024.0,
1459
                audio_size/1024.0,
1460
                extra_size/1024.0,
1461
                100.0*(total_size - raw)/raw
1462
        );
1463
    }
1464
}
1465

    
1466
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1467
static int output_packet(AVInputStream *ist, int ist_index,
1468
                         AVOutputStream **ost_table, int nb_ostreams,
1469
                         const AVPacket *pkt)
1470
{
1471
    AVFormatContext *os;
1472
    AVOutputStream *ost;
1473
    int ret, i;
1474
    int got_picture;
1475
    AVFrame picture;
1476
    void *buffer_to_free;
1477
    static unsigned int samples_size= 0;
1478
    AVSubtitle subtitle, *subtitle_to_free;
1479
    int64_t pkt_pts = AV_NOPTS_VALUE;
1480
#if CONFIG_AVFILTER
1481
    int frame_available;
1482
#endif
1483

    
1484
    AVPacket avpkt;
1485
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1486

    
1487
    if(ist->next_pts == AV_NOPTS_VALUE)
1488
        ist->next_pts= ist->pts;
1489

    
1490
    if (pkt == NULL) {
1491
        /* EOF handling */
1492
        av_init_packet(&avpkt);
1493
        avpkt.data = NULL;
1494
        avpkt.size = 0;
1495
        goto handle_eof;
1496
    } else {
1497
        avpkt = *pkt;
1498
    }
1499

    
1500
    if(pkt->dts != AV_NOPTS_VALUE)
1501
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1502
    if(pkt->pts != AV_NOPTS_VALUE)
1503
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1504

    
1505
    //while we have more to decode or while the decoder did output something on EOF
1506
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1507
        uint8_t *data_buf, *decoded_data_buf;
1508
        int data_size, decoded_data_size;
1509
    handle_eof:
1510
        ist->pts= ist->next_pts;
1511

    
1512
        if(avpkt.size && avpkt.size != pkt->size &&
1513
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1514
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1515
            ist->showed_multi_packet_warning=1;
1516
        }
1517

    
1518
        /* decode the packet if needed */
1519
        decoded_data_buf = NULL; /* fail safe */
1520
        decoded_data_size= 0;
1521
        data_buf  = avpkt.data;
1522
        data_size = avpkt.size;
1523
        subtitle_to_free = NULL;
1524
        if (ist->decoding_needed) {
1525
            switch(ist->st->codec->codec_type) {
1526
            case AVMEDIA_TYPE_AUDIO:{
1527
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1528
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1529
                    av_free(samples);
1530
                    samples= av_malloc(samples_size);
1531
                }
1532
                decoded_data_size= samples_size;
1533
                    /* XXX: could avoid copy if PCM 16 bits with same
1534
                       endianness as CPU */
1535
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1536
                                            &avpkt);
1537
                if (ret < 0)
1538
                    goto fail_decode;
1539
                avpkt.data += ret;
1540
                avpkt.size -= ret;
1541
                data_size   = ret;
1542
                /* Some bug in mpeg audio decoder gives */
1543
                /* decoded_data_size < 0, it seems they are overflows */
1544
                if (decoded_data_size <= 0) {
1545
                    /* no audio frame */
1546
                    continue;
1547
                }
1548
                decoded_data_buf = (uint8_t *)samples;
1549
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1550
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1551
                break;}
1552
            case AVMEDIA_TYPE_VIDEO:
1553
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1554
                    /* XXX: allocate picture correctly */
1555
                    avcodec_get_frame_defaults(&picture);
1556
                    avpkt.pts = pkt_pts;
1557
                    avpkt.dts = ist->pts;
1558
                    pkt_pts = AV_NOPTS_VALUE;
1559

    
1560
                    ret = avcodec_decode_video2(ist->st->codec,
1561
                                                &picture, &got_picture, &avpkt);
1562
                    ist->st->quality= picture.quality;
1563
                    if (ret < 0)
1564
                        goto fail_decode;
1565
                    if (!got_picture) {
1566
                        /* no picture yet */
1567
                        goto discard_packet;
1568
                    }
1569
                    ist->next_pts = ist->pts = picture.best_effort_timestamp;
1570
                    if (ist->st->codec->time_base.num != 0) {
1571
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1572
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1573
                                          ist->st->codec->time_base.num * ticks) /
1574
                            ist->st->codec->time_base.den;
1575
                    }
1576
                    avpkt.size = 0;
1577
                    break;
1578
            case AVMEDIA_TYPE_SUBTITLE:
1579
                ret = avcodec_decode_subtitle2(ist->st->codec,
1580
                                               &subtitle, &got_picture, &avpkt);
1581
                if (ret < 0)
1582
                    goto fail_decode;
1583
                if (!got_picture) {
1584
                    goto discard_packet;
1585
                }
1586
                subtitle_to_free = &subtitle;
1587
                avpkt.size = 0;
1588
                break;
1589
            default:
1590
                goto fail_decode;
1591
            }
1592
        } else {
1593
            switch(ist->st->codec->codec_type) {
1594
            case AVMEDIA_TYPE_AUDIO:
1595
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1596
                    ist->st->codec->sample_rate;
1597
                break;
1598
            case AVMEDIA_TYPE_VIDEO:
1599
                if (ist->st->codec->time_base.num != 0) {
1600
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1601
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1602
                                      ist->st->codec->time_base.num * ticks) /
1603
                        ist->st->codec->time_base.den;
1604
                }
1605
                break;
1606
            }
1607
            ret = avpkt.size;
1608
            avpkt.size = 0;
1609
        }
1610

    
1611
        buffer_to_free = NULL;
1612
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1613
            pre_process_video_frame(ist, (AVPicture *)&picture,
1614
                                    &buffer_to_free);
1615
        }
1616

    
1617
#if CONFIG_AVFILTER
1618
        if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
1619
            for(i=0;i<nb_ostreams;i++) {
1620
                ost = ost_table[i];
1621
                if (ost->input_video_filter && ost->source_index == ist_index) {
1622
                    AVRational sar;
1623
                    if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1624
                    else                                  sar = ist->st->codec->sample_aspect_ratio;
1625
                    // add it to be filtered
1626
                    av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1627
                                             ist->pts,
1628
                                             sar);
1629
                }
1630
            }
1631
        }
1632
#endif
1633

    
1634
        // preprocess audio (volume)
1635
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1636
            if (audio_volume != 256) {
1637
                short *volp;
1638
                volp = samples;
1639
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1640
                    int v = ((*volp) * audio_volume + 128) >> 8;
1641
                    if (v < -32768) v = -32768;
1642
                    if (v >  32767) v = 32767;
1643
                    *volp++ = v;
1644
                }
1645
            }
1646
        }
1647

    
1648
        /* frame rate emulation */
1649
        if (rate_emu) {
1650
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1651
            int64_t now = av_gettime() - ist->start;
1652
            if (pts > now)
1653
                usleep(pts - now);
1654
        }
1655
        /* if output time reached then transcode raw format,
1656
           encode packets and output them */
1657
        if (start_time == 0 || ist->pts >= start_time)
1658
            for(i=0;i<nb_ostreams;i++) {
1659
                int frame_size;
1660

    
1661
                ost = ost_table[i];
1662
                if (ost->source_index == ist_index) {
1663
#if CONFIG_AVFILTER
1664
                frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1665
                    !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1666
                while (frame_available) {
1667
                    AVRational ist_pts_tb;
1668
                    if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1669
                        get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1670
                    if (ost->picref)
1671
                        ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1672
#endif
1673
                    os = output_files[ost->file_index];
1674

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

    
1678
                    if (ost->encoding_needed) {
1679
                        av_assert0(ist->decoding_needed);
1680
                        switch(ost->st->codec->codec_type) {
1681
                        case AVMEDIA_TYPE_AUDIO:
1682
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1683
                            break;
1684
                        case AVMEDIA_TYPE_VIDEO:
1685
#if CONFIG_AVFILTER
1686
                            if (ost->picref->video)
1687
                                ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1688
#endif
1689
                            do_video_out(os, ost, ist, &picture, &frame_size);
1690
                            if (vstats_filename && frame_size)
1691
                                do_video_stats(os, ost, frame_size);
1692
                            break;
1693
                        case AVMEDIA_TYPE_SUBTITLE:
1694
                            do_subtitle_out(os, ost, ist, &subtitle,
1695
                                            pkt->pts);
1696
                            break;
1697
                        default:
1698
                            abort();
1699
                        }
1700
                    } else {
1701
                        AVFrame avframe; //FIXME/XXX remove this
1702
                        AVPacket opkt;
1703
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1704

    
1705
                        av_init_packet(&opkt);
1706

    
1707
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1708
#if !CONFIG_AVFILTER
1709
                            continue;
1710
#else
1711
                            goto cont;
1712
#endif
1713

    
1714
                        /* no reencoding needed : output the packet directly */
1715
                        /* force the input stream PTS */
1716

    
1717
                        avcodec_get_frame_defaults(&avframe);
1718
                        ost->st->codec->coded_frame= &avframe;
1719
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1720

    
1721
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1722
                            audio_size += data_size;
1723
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1724
                            video_size += data_size;
1725
                            ost->sync_opts++;
1726
                        }
1727

    
1728
                        opkt.stream_index= ost->index;
1729
                        if(pkt->pts != AV_NOPTS_VALUE)
1730
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1731
                        else
1732
                            opkt.pts= AV_NOPTS_VALUE;
1733

    
1734
                        if (pkt->dts == AV_NOPTS_VALUE)
1735
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1736
                        else
1737
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1738
                        opkt.dts -= ost_tb_start_time;
1739

    
1740
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1741
                        opkt.flags= pkt->flags;
1742

    
1743
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1744
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1745
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1746
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1747
                           ) {
1748
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1749
                                opkt.destruct= av_destruct_packet;
1750
                        } else {
1751
                            opkt.data = data_buf;
1752
                            opkt.size = data_size;
1753
                        }
1754

    
1755
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1756
                        ost->st->codec->frame_number++;
1757
                        ost->frame_number++;
1758
                        av_free_packet(&opkt);
1759
                    }
1760
#if CONFIG_AVFILTER
1761
                    cont:
1762
                    frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1763
                                       ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1764
                    if(ost->picref)
1765
                        avfilter_unref_buffer(ost->picref);
1766
                }
1767
#endif
1768
                }
1769
            }
1770

    
1771
        av_free(buffer_to_free);
1772
        /* XXX: allocate the subtitles in the codec ? */
1773
        if (subtitle_to_free) {
1774
            avsubtitle_free(subtitle_to_free);
1775
            subtitle_to_free = NULL;
1776
        }
1777
    }
1778
 discard_packet:
1779
    if (pkt == NULL) {
1780
        /* EOF handling */
1781

    
1782
        for(i=0;i<nb_ostreams;i++) {
1783
            ost = ost_table[i];
1784
            if (ost->source_index == ist_index) {
1785
                AVCodecContext *enc= ost->st->codec;
1786
                os = output_files[ost->file_index];
1787

    
1788
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1789
                    continue;
1790
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1791
                    continue;
1792

    
1793
                if (ost->encoding_needed) {
1794
                    for(;;) {
1795
                        AVPacket pkt;
1796
                        int fifo_bytes;
1797
                        av_init_packet(&pkt);
1798
                        pkt.stream_index= ost->index;
1799

    
1800
                        switch(ost->st->codec->codec_type) {
1801
                        case AVMEDIA_TYPE_AUDIO:
1802
                            fifo_bytes = av_fifo_size(ost->fifo);
1803
                            ret = 0;
1804
                            /* encode any samples remaining in fifo */
1805
                            if (fifo_bytes > 0) {
1806
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1807
                                int fs_tmp = enc->frame_size;
1808

    
1809
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1810
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1811
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1812
                                } else { /* pad */
1813
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1814
                                    if (allocated_audio_buf_size < frame_bytes)
1815
                                        ffmpeg_exit(1);
1816
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1817
                                }
1818

    
1819
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1820
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1821
                                                          ost->st->time_base.num, enc->sample_rate);
1822
                                enc->frame_size = fs_tmp;
1823
                            }
1824
                            if(ret <= 0) {
1825
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1826
                            }
1827
                            if (ret < 0) {
1828
                                fprintf(stderr, "Audio encoding failed\n");
1829
                                ffmpeg_exit(1);
1830
                            }
1831
                            audio_size += ret;
1832
                            pkt.flags |= AV_PKT_FLAG_KEY;
1833
                            break;
1834
                        case AVMEDIA_TYPE_VIDEO:
1835
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1836
                            if (ret < 0) {
1837
                                fprintf(stderr, "Video encoding failed\n");
1838
                                ffmpeg_exit(1);
1839
                            }
1840
                            video_size += ret;
1841
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1842
                                pkt.flags |= AV_PKT_FLAG_KEY;
1843
                            if (ost->logfile && enc->stats_out) {
1844
                                fprintf(ost->logfile, "%s", enc->stats_out);
1845
                            }
1846
                            break;
1847
                        default:
1848
                            ret=-1;
1849
                        }
1850

    
1851
                        if(ret<=0)
1852
                            break;
1853
                        pkt.data= bit_buffer;
1854
                        pkt.size= ret;
1855
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1856
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1857
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1858
                    }
1859
                }
1860
            }
1861
        }
1862
    }
1863

    
1864
    return 0;
1865
 fail_decode:
1866
    return -1;
1867
}
1868

    
1869
static void print_sdp(AVFormatContext **avc, int n)
1870
{
1871
    char sdp[2048];
1872

    
1873
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1874
    printf("SDP:\n%s\n", sdp);
1875
    fflush(stdout);
1876
}
1877

    
1878
static int copy_chapters(int infile, int outfile)
1879
{
1880
    AVFormatContext *is = input_files[infile];
1881
    AVFormatContext *os = output_files[outfile];
1882
    int i;
1883

    
1884
    for (i = 0; i < is->nb_chapters; i++) {
1885
        AVChapter *in_ch = is->chapters[i], *out_ch;
1886
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1887
                                      AV_TIME_BASE_Q, in_ch->time_base);
1888
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1889
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1890

    
1891

    
1892
        if (in_ch->end < ts_off)
1893
            continue;
1894
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1895
            break;
1896

    
1897
        out_ch = av_mallocz(sizeof(AVChapter));
1898
        if (!out_ch)
1899
            return AVERROR(ENOMEM);
1900

    
1901
        out_ch->id        = in_ch->id;
1902
        out_ch->time_base = in_ch->time_base;
1903
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1904
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1905

    
1906
        if (metadata_chapters_autocopy)
1907
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1908

    
1909
        os->nb_chapters++;
1910
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1911
        if (!os->chapters)
1912
            return AVERROR(ENOMEM);
1913
        os->chapters[os->nb_chapters - 1] = out_ch;
1914
    }
1915
    return 0;
1916
}
1917

    
1918
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1919
                                    AVCodecContext *avctx)
1920
{
1921
    char *p;
1922
    int n = 1, i;
1923
    int64_t t;
1924

    
1925
    for (p = kf; *p; p++)
1926
        if (*p == ',')
1927
            n++;
1928
    ost->forced_kf_count = n;
1929
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1930
    if (!ost->forced_kf_pts) {
1931
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1932
        ffmpeg_exit(1);
1933
    }
1934
    for (i = 0; i < n; i++) {
1935
        p = i ? strchr(p, ',') + 1 : kf;
1936
        t = parse_time_or_die("force_key_frames", p, 1);
1937
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1938
    }
1939
}
1940

    
1941
/*
1942
 * The following code is the main loop of the file converter
1943
 */
1944
static int transcode(AVFormatContext **output_files,
1945
                     int nb_output_files,
1946
                     AVFormatContext **input_files,
1947
                     int nb_input_files,
1948
                     AVStreamMap *stream_maps, int nb_stream_maps)
1949
{
1950
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1951
    AVFormatContext *is, *os;
1952
    AVCodecContext *codec, *icodec;
1953
    AVOutputStream *ost, **ost_table = NULL;
1954
    AVInputStream *ist, **ist_table = NULL;
1955
    AVInputFile *file_table;
1956
    char error[1024];
1957
    int key;
1958
    int want_sdp = 1;
1959
    uint8_t no_packet[MAX_FILES]={0};
1960
    int no_packet_count=0;
1961

    
1962
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1963
    if (!file_table)
1964
        goto fail;
1965

    
1966
    /* input stream init */
1967
    j = 0;
1968
    for(i=0;i<nb_input_files;i++) {
1969
        is = input_files[i];
1970
        file_table[i].ist_index = j;
1971
        file_table[i].nb_streams = is->nb_streams;
1972
        j += is->nb_streams;
1973
    }
1974
    nb_istreams = j;
1975

    
1976
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1977
    if (!ist_table)
1978
        goto fail;
1979

    
1980
    for(i=0;i<nb_istreams;i++) {
1981
        ist = av_mallocz(sizeof(AVInputStream));
1982
        if (!ist)
1983
            goto fail;
1984
        ist_table[i] = ist;
1985
    }
1986
    j = 0;
1987
    for(i=0;i<nb_input_files;i++) {
1988
        is = input_files[i];
1989
        for(k=0;k<is->nb_streams;k++) {
1990
            ist = ist_table[j++];
1991
            ist->st = is->streams[k];
1992
            ist->file_index = i;
1993
            ist->index = k;
1994
            ist->discard = 1; /* the stream is discarded by default
1995
                                 (changed later) */
1996

    
1997
            if (rate_emu) {
1998
                ist->start = av_gettime();
1999
            }
2000
        }
2001
    }
2002

    
2003
    /* output stream init */
2004
    nb_ostreams = 0;
2005
    for(i=0;i<nb_output_files;i++) {
2006
        os = output_files[i];
2007
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2008
            av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2009
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2010
            ret = AVERROR(EINVAL);
2011
            goto fail;
2012
        }
2013
        nb_ostreams += os->nb_streams;
2014
    }
2015
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2016
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
2017
        ret = AVERROR(EINVAL);
2018
        goto fail;
2019
    }
2020

    
2021
    /* Sanity check the mapping args -- do the input files & streams exist? */
2022
    for(i=0;i<nb_stream_maps;i++) {
2023
        int fi = stream_maps[i].file_index;
2024
        int si = stream_maps[i].stream_index;
2025

    
2026
        if (fi < 0 || fi > nb_input_files - 1 ||
2027
            si < 0 || si > file_table[fi].nb_streams - 1) {
2028
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2029
            ret = AVERROR(EINVAL);
2030
            goto fail;
2031
        }
2032
        fi = stream_maps[i].sync_file_index;
2033
        si = stream_maps[i].sync_stream_index;
2034
        if (fi < 0 || fi > nb_input_files - 1 ||
2035
            si < 0 || si > file_table[fi].nb_streams - 1) {
2036
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2037
            ret = AVERROR(EINVAL);
2038
            goto fail;
2039
        }
2040
    }
2041

    
2042
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2043
    if (!ost_table)
2044
        goto fail;
2045
    n = 0;
2046
    for(k=0;k<nb_output_files;k++) {
2047
        os = output_files[k];
2048
        for(i=0;i<os->nb_streams;i++,n++) {
2049
            int found;
2050
            ost = ost_table[n] = output_streams_for_file[k][i];
2051
            ost->st = os->streams[i];
2052
            if (nb_stream_maps > 0) {
2053
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2054
                    stream_maps[n].stream_index;
2055

    
2056
                /* Sanity check that the stream types match */
2057
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2058
                    int i= ost->file_index;
2059
                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2060
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2061
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2062
                        ost->file_index, ost->index);
2063
                    ffmpeg_exit(1);
2064
                }
2065

    
2066
            } else {
2067
                int best_nb_frames=-1;
2068
                /* get corresponding input stream index : we select the first one with the right type */
2069
                found = 0;
2070
                for(j=0;j<nb_istreams;j++) {
2071
                    int skip=0;
2072
                    ist = ist_table[j];
2073
                    if(opt_programid){
2074
                        int pi,si;
2075
                        AVFormatContext *f= input_files[ ist->file_index ];
2076
                        skip=1;
2077
                        for(pi=0; pi<f->nb_programs; pi++){
2078
                            AVProgram *p= f->programs[pi];
2079
                            if(p->id == opt_programid)
2080
                                for(si=0; si<p->nb_stream_indexes; si++){
2081
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2082
                                        skip=0;
2083
                                }
2084
                        }
2085
                    }
2086
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2087
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2088
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2089
                            best_nb_frames= ist->st->codec_info_nb_frames;
2090
                            ost->source_index = j;
2091
                            found = 1;
2092
                        }
2093
                    }
2094
                }
2095

    
2096
                if (!found) {
2097
                    if(! opt_programid) {
2098
                        /* try again and reuse existing stream */
2099
                        for(j=0;j<nb_istreams;j++) {
2100
                            ist = ist_table[j];
2101
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2102
                                && ist->st->discard != AVDISCARD_ALL) {
2103
                                ost->source_index = j;
2104
                                found = 1;
2105
                            }
2106
                        }
2107
                    }
2108
                    if (!found) {
2109
                        int i= ost->file_index;
2110
                        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2111
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2112
                                ost->file_index, ost->index);
2113
                        ffmpeg_exit(1);
2114
                    }
2115
                }
2116
            }
2117
            ist = ist_table[ost->source_index];
2118
            ist->discard = 0;
2119
            ost->sync_ist = (nb_stream_maps > 0) ?
2120
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2121
                         stream_maps[n].sync_stream_index] : ist;
2122
        }
2123
    }
2124

    
2125
    /* for each output stream, we compute the right encoding parameters */
2126
    for(i=0;i<nb_ostreams;i++) {
2127
        ost = ost_table[i];
2128
        os = output_files[ost->file_index];
2129
        ist = ist_table[ost->source_index];
2130

    
2131
        codec = ost->st->codec;
2132
        icodec = ist->st->codec;
2133

    
2134
        if (metadata_streams_autocopy)
2135
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2136
                             AV_METADATA_DONT_OVERWRITE);
2137

    
2138
        ost->st->disposition = ist->st->disposition;
2139
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2140
        codec->chroma_sample_location = icodec->chroma_sample_location;
2141

    
2142
        if (ost->st->stream_copy) {
2143
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2144

    
2145
            if (extra_size > INT_MAX)
2146
                goto fail;
2147

    
2148
            /* if stream_copy is selected, no need to decode or encode */
2149
            codec->codec_id = icodec->codec_id;
2150
            codec->codec_type = icodec->codec_type;
2151

    
2152
            if(!codec->codec_tag){
2153
                if(   !os->oformat->codec_tag
2154
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2155
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2156
                    codec->codec_tag = icodec->codec_tag;
2157
            }
2158

    
2159
            codec->bit_rate = icodec->bit_rate;
2160
            codec->rc_max_rate    = icodec->rc_max_rate;
2161
            codec->rc_buffer_size = icodec->rc_buffer_size;
2162
            codec->extradata= av_mallocz(extra_size);
2163
            if (!codec->extradata)
2164
                goto fail;
2165
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2166
            codec->extradata_size= icodec->extradata_size;
2167
            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){
2168
                codec->time_base = icodec->time_base;
2169
                codec->time_base.num *= icodec->ticks_per_frame;
2170
                av_reduce(&codec->time_base.num, &codec->time_base.den,
2171
                          codec->time_base.num, codec->time_base.den, INT_MAX);
2172
            }else
2173
                codec->time_base = ist->st->time_base;
2174
            switch(codec->codec_type) {
2175
            case AVMEDIA_TYPE_AUDIO:
2176
                if(audio_volume != 256) {
2177
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2178
                    ffmpeg_exit(1);
2179
                }
2180
                codec->channel_layout = icodec->channel_layout;
2181
                codec->sample_rate = icodec->sample_rate;
2182
                codec->channels = icodec->channels;
2183
                codec->frame_size = icodec->frame_size;
2184
                codec->audio_service_type = icodec->audio_service_type;
2185
                codec->block_align= icodec->block_align;
2186
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2187
                    codec->block_align= 0;
2188
                if(codec->codec_id == CODEC_ID_AC3)
2189
                    codec->block_align= 0;
2190
                break;
2191
            case AVMEDIA_TYPE_VIDEO:
2192
                codec->pix_fmt = icodec->pix_fmt;
2193
                codec->width = icodec->width;
2194
                codec->height = icodec->height;
2195
                codec->has_b_frames = icodec->has_b_frames;
2196
                break;
2197
            case AVMEDIA_TYPE_SUBTITLE:
2198
                codec->width = icodec->width;
2199
                codec->height = icodec->height;
2200
                break;
2201
            default:
2202
                abort();
2203
            }
2204
        } else {
2205
            switch(codec->codec_type) {
2206
            case AVMEDIA_TYPE_AUDIO:
2207
                ost->fifo= av_fifo_alloc(1024);
2208
                if(!ost->fifo)
2209
                    goto fail;
2210
                ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2211
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2212
                icodec->request_channels = codec->channels;
2213
                ist->decoding_needed = 1;
2214
                ost->encoding_needed = 1;
2215
                ost->resample_sample_fmt  = icodec->sample_fmt;
2216
                ost->resample_sample_rate = icodec->sample_rate;
2217
                ost->resample_channels    = icodec->channels;
2218
                break;
2219
            case AVMEDIA_TYPE_VIDEO:
2220
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2221
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2222
                    ffmpeg_exit(1);
2223
                }
2224
                ost->video_resample = (codec->width != icodec->width   ||
2225
                                       codec->height != icodec->height ||
2226
                        (codec->pix_fmt != icodec->pix_fmt));
2227
                if (ost->video_resample) {
2228
#if !CONFIG_AVFILTER
2229
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2230
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2231
                                         codec->width, codec->height)) {
2232
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2233
                        ffmpeg_exit(1);
2234
                    }
2235
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2236
                    ost->img_resample_ctx = sws_getContext(
2237
                        icodec->width,
2238
                        icodec->height,
2239
                            icodec->pix_fmt,
2240
                            codec->width,
2241
                            codec->height,
2242
                            codec->pix_fmt,
2243
                            sws_flags, NULL, NULL, NULL);
2244
                    if (ost->img_resample_ctx == NULL) {
2245
                        fprintf(stderr, "Cannot get resampling context\n");
2246
                        ffmpeg_exit(1);
2247
                    }
2248

    
2249
                    ost->original_height = icodec->height;
2250
                    ost->original_width  = icodec->width;
2251
#endif
2252
                    codec->bits_per_raw_sample= 0;
2253
                }
2254
                ost->resample_height = icodec->height;
2255
                ost->resample_width  = icodec->width;
2256
                ost->resample_pix_fmt= icodec->pix_fmt;
2257
                ost->encoding_needed = 1;
2258
                ist->decoding_needed = 1;
2259

    
2260
#if CONFIG_AVFILTER
2261
                if (configure_filters(ist, ost)) {
2262
                    fprintf(stderr, "Error opening filters!\n");
2263
                    exit(1);
2264
                }
2265
#endif
2266
                break;
2267
            case AVMEDIA_TYPE_SUBTITLE:
2268
                ost->encoding_needed = 1;
2269
                ist->decoding_needed = 1;
2270
                break;
2271
            default:
2272
                abort();
2273
                break;
2274
            }
2275
            /* two pass mode */
2276
            if (ost->encoding_needed &&
2277
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2278
                char logfilename[1024];
2279
                FILE *f;
2280

    
2281
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2282
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2283
                         i);
2284
                if (codec->flags & CODEC_FLAG_PASS1) {
2285
                    f = fopen(logfilename, "wb");
2286
                    if (!f) {
2287
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2288
                        ffmpeg_exit(1);
2289
                    }
2290
                    ost->logfile = f;
2291
                } else {
2292
                    char  *logbuffer;
2293
                    size_t logbuffer_size;
2294
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2295
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2296
                        ffmpeg_exit(1);
2297
                    }
2298
                    codec->stats_in = logbuffer;
2299
                }
2300
            }
2301
        }
2302
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2303
            int size= codec->width * codec->height;
2304
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2305
        }
2306
    }
2307

    
2308
    if (!bit_buffer)
2309
        bit_buffer = av_malloc(bit_buffer_size);
2310
    if (!bit_buffer) {
2311
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2312
                bit_buffer_size);
2313
        ret = AVERROR(ENOMEM);
2314
        goto fail;
2315
    }
2316

    
2317
    /* open each encoder */
2318
    for(i=0;i<nb_ostreams;i++) {
2319
        ost = ost_table[i];
2320
        if (ost->encoding_needed) {
2321
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2322
            AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2323
            if (!codec)
2324
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2325
            if (!codec) {
2326
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2327
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2328
                ret = AVERROR(EINVAL);
2329
                goto dump_format;
2330
            }
2331
            if (dec->subtitle_header) {
2332
                ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2333
                if (!ost->st->codec->subtitle_header) {
2334
                    ret = AVERROR(ENOMEM);
2335
                    goto dump_format;
2336
                }
2337
                memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2338
                ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2339
            }
2340
            if (avcodec_open(ost->st->codec, codec) < 0) {
2341
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2342
                        ost->file_index, ost->index);
2343
                ret = AVERROR(EINVAL);
2344
                goto dump_format;
2345
            }
2346
            extra_size += ost->st->codec->extradata_size;
2347
        }
2348
    }
2349

    
2350
    /* open each decoder */
2351
    for(i=0;i<nb_istreams;i++) {
2352
        ist = ist_table[i];
2353
        if (ist->decoding_needed) {
2354
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2355
            if (!codec)
2356
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2357
            if (!codec) {
2358
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2359
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2360
                ret = AVERROR(EINVAL);
2361
                goto dump_format;
2362
            }
2363
            if (avcodec_open(ist->st->codec, codec) < 0) {
2364
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2365
                        ist->file_index, ist->index);
2366
                ret = AVERROR(EINVAL);
2367
                goto dump_format;
2368
            }
2369
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2370
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2371
        }
2372
    }
2373

    
2374
    /* init pts */
2375
    for(i=0;i<nb_istreams;i++) {
2376
        AVStream *st;
2377
        ist = ist_table[i];
2378
        st= ist->st;
2379
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2380
        ist->next_pts = AV_NOPTS_VALUE;
2381
        ist->is_start = 1;
2382
    }
2383

    
2384
    /* set meta data information from input file if required */
2385
    for (i=0;i<nb_meta_data_maps;i++) {
2386
        AVFormatContext *files[2];
2387
        AVMetadata      **meta[2];
2388
        int j;
2389

    
2390
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2391
        if ((index) < 0 || (index) >= (nb_elems)) {\
2392
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2393
                     (desc), (index));\
2394
            ret = AVERROR(EINVAL);\
2395
            goto dump_format;\
2396
        }
2397

    
2398
        int out_file_index = meta_data_maps[i][0].file;
2399
        int in_file_index = meta_data_maps[i][1].file;
2400
        if (in_file_index < 0 || out_file_index < 0)
2401
            continue;
2402
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2403
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2404

    
2405
        files[0] = output_files[out_file_index];
2406
        files[1] = input_files[in_file_index];
2407

    
2408
        for (j = 0; j < 2; j++) {
2409
            AVMetaDataMap *map = &meta_data_maps[i][j];
2410

    
2411
            switch (map->type) {
2412
            case 'g':
2413
                meta[j] = &files[j]->metadata;
2414
                break;
2415
            case 's':
2416
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2417
                meta[j] = &files[j]->streams[map->index]->metadata;
2418
                break;
2419
            case 'c':
2420
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2421
                meta[j] = &files[j]->chapters[map->index]->metadata;
2422
                break;
2423
            case 'p':
2424
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2425
                meta[j] = &files[j]->programs[map->index]->metadata;
2426
                break;
2427
            }
2428
        }
2429

    
2430
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2431
    }
2432

    
2433
    /* copy global metadata by default */
2434
    if (metadata_global_autocopy) {
2435

    
2436
        for (i = 0; i < nb_output_files; i++)
2437
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2438
                             AV_METADATA_DONT_OVERWRITE);
2439
    }
2440

    
2441
    /* copy chapters according to chapter maps */
2442
    for (i = 0; i < nb_chapter_maps; i++) {
2443
        int infile  = chapter_maps[i].in_file;
2444
        int outfile = chapter_maps[i].out_file;
2445

    
2446
        if (infile < 0 || outfile < 0)
2447
            continue;
2448
        if (infile >= nb_input_files) {
2449
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2450
            ret = AVERROR(EINVAL);
2451
            goto dump_format;
2452
        }
2453
        if (outfile >= nb_output_files) {
2454
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2455
            ret = AVERROR(EINVAL);
2456
            goto dump_format;
2457
        }
2458
        copy_chapters(infile, outfile);
2459
    }
2460

    
2461
    /* copy chapters from the first input file that has them*/
2462
    if (!nb_chapter_maps)
2463
        for (i = 0; i < nb_input_files; i++) {
2464
            if (!input_files[i]->nb_chapters)
2465
                continue;
2466

    
2467
            for (j = 0; j < nb_output_files; j++)
2468
                if ((ret = copy_chapters(i, j)) < 0)
2469
                    goto dump_format;
2470
            break;
2471
        }
2472

    
2473
    /* open files and write file headers */
2474
    for(i=0;i<nb_output_files;i++) {
2475
        os = output_files[i];
2476
        if (av_write_header(os) < 0) {
2477
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2478
            ret = AVERROR(EINVAL);
2479
            goto dump_format;
2480
        }
2481
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2482
            want_sdp = 0;
2483
        }
2484
    }
2485

    
2486
 dump_format:
2487
    /* dump the file output parameters - cannot be done before in case
2488
       of stream copy */
2489
    for(i=0;i<nb_output_files;i++) {
2490
        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2491
    }
2492

    
2493
    /* dump the stream mapping */
2494
    if (verbose >= 0) {
2495
        fprintf(stderr, "Stream mapping:\n");
2496
        for(i=0;i<nb_ostreams;i++) {
2497
            ost = ost_table[i];
2498
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2499
                    ist_table[ost->source_index]->file_index,
2500
                    ist_table[ost->source_index]->index,
2501
                    ost->file_index,
2502
                    ost->index);
2503
            if (ost->sync_ist != ist_table[ost->source_index])
2504
                fprintf(stderr, " [sync #%d.%d]",
2505
                        ost->sync_ist->file_index,
2506
                        ost->sync_ist->index);
2507
            fprintf(stderr, "\n");
2508
        }
2509
    }
2510

    
2511
    if (ret) {
2512
        fprintf(stderr, "%s\n", error);
2513
        goto fail;
2514
    }
2515

    
2516
    if (want_sdp) {
2517
        print_sdp(output_files, nb_output_files);
2518
    }
2519

    
2520
    if (!using_stdin) {
2521
        if(verbose >= 0)
2522
            fprintf(stderr, "Press [q] to stop encoding\n");
2523
        url_set_interrupt_cb(decode_interrupt_cb);
2524
    }
2525
    term_init();
2526

    
2527
    timer_start = av_gettime();
2528

    
2529
    for(; received_sigterm == 0;) {
2530
        int file_index, ist_index;
2531
        AVPacket pkt;
2532
        double ipts_min;
2533
        double opts_min;
2534

    
2535
    redo:
2536
        ipts_min= 1e100;
2537
        opts_min= 1e100;
2538
        /* if 'q' pressed, exits */
2539
        if (!using_stdin) {
2540
            if (q_pressed)
2541
                break;
2542
            /* read_key() returns 0 on EOF */
2543
            key = read_key();
2544
            if (key == 'q')
2545
                break;
2546
        }
2547

    
2548
        /* select the stream that we must read now by looking at the
2549
           smallest output pts */
2550
        file_index = -1;
2551
        for(i=0;i<nb_ostreams;i++) {
2552
            double ipts, opts;
2553
            ost = ost_table[i];
2554
            os = output_files[ost->file_index];
2555
            ist = ist_table[ost->source_index];
2556
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2557
                continue;
2558
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2559
            ipts = (double)ist->pts;
2560
            if (!file_table[ist->file_index].eof_reached){
2561
                if(ipts < ipts_min) {
2562
                    ipts_min = ipts;
2563
                    if(input_sync ) file_index = ist->file_index;
2564
                }
2565
                if(opts < opts_min) {
2566
                    opts_min = opts;
2567
                    if(!input_sync) file_index = ist->file_index;
2568
                }
2569
            }
2570
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2571
                file_index= -1;
2572
                break;
2573
            }
2574
        }
2575
        /* if none, if is finished */
2576
        if (file_index < 0) {
2577
            if(no_packet_count){
2578
                no_packet_count=0;
2579
                memset(no_packet, 0, sizeof(no_packet));
2580
                usleep(10000);
2581
                continue;
2582
            }
2583
            break;
2584
        }
2585

    
2586
        /* finish if limit size exhausted */
2587
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2588
            break;
2589

    
2590
        /* read a frame from it and output it in the fifo */
2591
        is = input_files[file_index];
2592
        ret= av_read_frame(is, &pkt);
2593
        if(ret == AVERROR(EAGAIN)){
2594
            no_packet[file_index]=1;
2595
            no_packet_count++;
2596
            continue;
2597
        }
2598
        if (ret < 0) {
2599
            file_table[file_index].eof_reached = 1;
2600
            if (opt_shortest)
2601
                break;
2602
            else
2603
                continue;
2604
        }
2605

    
2606
        no_packet_count=0;
2607
        memset(no_packet, 0, sizeof(no_packet));
2608

    
2609
        if (do_pkt_dump) {
2610
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2611
                             is->streams[pkt.stream_index]);
2612
        }
2613
        /* the following test is needed in case new streams appear
2614
           dynamically in stream : we ignore them */
2615
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2616
            goto discard_packet;
2617
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2618
        ist = ist_table[ist_index];
2619
        if (ist->discard)
2620
            goto discard_packet;
2621

    
2622
        if (pkt.dts != AV_NOPTS_VALUE)
2623
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2624
        if (pkt.pts != AV_NOPTS_VALUE)
2625
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2626

    
2627
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2628
            && input_files_ts_scale[file_index][pkt.stream_index]){
2629
            if(pkt.pts != AV_NOPTS_VALUE)
2630
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2631
            if(pkt.dts != AV_NOPTS_VALUE)
2632
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2633
        }
2634

    
2635
//        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);
2636
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2637
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2638
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2639
            int64_t delta= pkt_dts - ist->next_pts;
2640
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2641
                input_files_ts_offset[ist->file_index]-= delta;
2642
                if (verbose > 2)
2643
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2644
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2645
                if(pkt.pts != AV_NOPTS_VALUE)
2646
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2647
            }
2648
        }
2649

    
2650
        /* finish if recording time exhausted */
2651
        if (recording_time != INT64_MAX &&
2652
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2653
            ist->is_past_recording_time = 1;
2654
            goto discard_packet;
2655
        }
2656

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

    
2660
            if (verbose >= 0)
2661
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2662
                        ist->file_index, ist->index);
2663
            if (exit_on_error)
2664
                ffmpeg_exit(1);
2665
            av_free_packet(&pkt);
2666
            goto redo;
2667
        }
2668

    
2669
    discard_packet:
2670
        av_free_packet(&pkt);
2671

    
2672
        /* dump report by using the output first video and audio streams */
2673
        print_report(output_files, ost_table, nb_ostreams, 0);
2674
    }
2675

    
2676
    /* at the end of stream, we must flush the decoder buffers */
2677
    for(i=0;i<nb_istreams;i++) {
2678
        ist = ist_table[i];
2679
        if (ist->decoding_needed) {
2680
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2681
        }
2682
    }
2683

    
2684
    term_exit();
2685

    
2686
    /* write the trailer if needed and close file */
2687
    for(i=0;i<nb_output_files;i++) {
2688
        os = output_files[i];
2689
        av_write_trailer(os);
2690
    }
2691

    
2692
    /* dump report by using the first video and audio streams */
2693
    print_report(output_files, ost_table, nb_ostreams, 1);
2694

    
2695
    /* close each encoder */
2696
    for(i=0;i<nb_ostreams;i++) {
2697
        ost = ost_table[i];
2698
        if (ost->encoding_needed) {
2699
            av_freep(&ost->st->codec->stats_in);
2700
            avcodec_close(ost->st->codec);
2701
        }
2702
#if CONFIG_AVFILTER
2703
        avfilter_graph_free(&ost->graph);
2704
#endif
2705
    }
2706

    
2707
    /* close each decoder */
2708
    for(i=0;i<nb_istreams;i++) {
2709
        ist = ist_table[i];
2710
        if (ist->decoding_needed) {
2711
            avcodec_close(ist->st->codec);
2712
        }
2713
    }
2714

    
2715
    /* finished ! */
2716
    ret = 0;
2717

    
2718
 fail:
2719
    av_freep(&bit_buffer);
2720
    av_free(file_table);
2721

    
2722
    if (ist_table) {
2723
        for(i=0;i<nb_istreams;i++) {
2724
            ist = ist_table[i];
2725
            av_free(ist);
2726
        }
2727
        av_free(ist_table);
2728
    }
2729
    if (ost_table) {
2730
        for(i=0;i<nb_ostreams;i++) {
2731
            ost = ost_table[i];
2732
            if (ost) {
2733
                if (ost->st->stream_copy)
2734
                    av_freep(&ost->st->codec->extradata);
2735
                if (ost->logfile) {
2736
                    fclose(ost->logfile);
2737
                    ost->logfile = NULL;
2738
                }
2739
                av_fifo_free(ost->fifo); /* works even if fifo is not
2740
                                             initialized but set to zero */
2741
                av_freep(&ost->st->codec->subtitle_header);
2742
                av_free(ost->pict_tmp.data[0]);
2743
                av_free(ost->forced_kf_pts);
2744
                if (ost->video_resample)
2745
                    sws_freeContext(ost->img_resample_ctx);
2746
                if (ost->resample)
2747
                    audio_resample_close(ost->resample);
2748
                if (ost->reformat_ctx)
2749
                    av_audio_convert_free(ost->reformat_ctx);
2750
                av_free(ost);
2751
            }
2752
        }
2753
        av_free(ost_table);
2754
    }
2755
    return ret;
2756
}
2757

    
2758
static void opt_format(const char *arg)
2759
{
2760
    last_asked_format = arg;
2761
}
2762

    
2763
static void opt_video_rc_override_string(const char *arg)
2764
{
2765
    video_rc_override_string = arg;
2766
}
2767

    
2768
static int opt_me_threshold(const char *opt, const char *arg)
2769
{
2770
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2771
    return 0;
2772
}
2773

    
2774
static int opt_verbose(const char *opt, const char *arg)
2775
{
2776
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2777
    return 0;
2778
}
2779

    
2780
static int opt_frame_rate(const char *opt, const char *arg)
2781
{
2782
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2783
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2784
        ffmpeg_exit(1);
2785
    }
2786
    return 0;
2787
}
2788

    
2789
static int opt_bitrate(const char *opt, const char *arg)
2790
{
2791
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2792

    
2793
    opt_default(opt, arg);
2794

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

    
2798
    return 0;
2799
}
2800

    
2801
static int opt_frame_crop(const char *opt, const char *arg)
2802
{
2803
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2804
    return AVERROR(EINVAL);
2805
}
2806

    
2807
static void opt_frame_size(const char *arg)
2808
{
2809
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2810
        fprintf(stderr, "Incorrect frame size\n");
2811
        ffmpeg_exit(1);
2812
    }
2813
}
2814

    
2815
static int opt_pad(const char *opt, const char *arg) {
2816
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2817
    return -1;
2818
}
2819

    
2820
static void opt_frame_pix_fmt(const char *arg)
2821
{
2822
    if (strcmp(arg, "list")) {
2823
        frame_pix_fmt = av_get_pix_fmt(arg);
2824
        if (frame_pix_fmt == PIX_FMT_NONE) {
2825
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2826
            ffmpeg_exit(1);
2827
        }
2828
    } else {
2829
        show_pix_fmts();
2830
        ffmpeg_exit(0);
2831
    }
2832
}
2833

    
2834
static void opt_frame_aspect_ratio(const char *arg)
2835
{
2836
    int x = 0, y = 0;
2837
    double ar = 0;
2838
    const char *p;
2839
    char *end;
2840

    
2841
    p = strchr(arg, ':');
2842
    if (p) {
2843
        x = strtol(arg, &end, 10);
2844
        if (end == p)
2845
            y = strtol(end+1, &end, 10);
2846
        if (x > 0 && y > 0)
2847
            ar = (double)x / (double)y;
2848
    } else
2849
        ar = strtod(arg, NULL);
2850

    
2851
    if (!ar) {
2852
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2853
        ffmpeg_exit(1);
2854
    }
2855
    frame_aspect_ratio = ar;
2856
}
2857

    
2858
static int opt_metadata(const char *opt, const char *arg)
2859
{
2860
    char *mid= strchr(arg, '=');
2861

    
2862
    if(!mid){
2863
        fprintf(stderr, "Missing =\n");
2864
        ffmpeg_exit(1);
2865
    }
2866
    *mid++= 0;
2867

    
2868
    av_metadata_set2(&metadata, arg, mid, 0);
2869

    
2870
    return 0;
2871
}
2872

    
2873
static void opt_qscale(const char *arg)
2874
{
2875
    video_qscale = atof(arg);
2876
    if (video_qscale <= 0 ||
2877
        video_qscale > 255) {
2878
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2879
        ffmpeg_exit(1);
2880
    }
2881
}
2882

    
2883
static void opt_top_field_first(const char *arg)
2884
{
2885
    top_field_first= atoi(arg);
2886
}
2887

    
2888
static int opt_thread_count(const char *opt, const char *arg)
2889
{
2890
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2891
#if !HAVE_THREADS
2892
    if (verbose >= 0)
2893
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2894
#endif
2895
    return 0;
2896
}
2897

    
2898
static void opt_audio_sample_fmt(const char *arg)
2899
{
2900
    if (strcmp(arg, "list")) {
2901
        audio_sample_fmt = av_get_sample_fmt(arg);
2902
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2903
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2904
            ffmpeg_exit(1);
2905
        }
2906
    } else {
2907
        int i;
2908
        char fmt_str[128];
2909
        for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2910
            printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2911
        ffmpeg_exit(0);
2912
    }
2913
}
2914

    
2915
static int opt_audio_rate(const char *opt, const char *arg)
2916
{
2917
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2918
    return 0;
2919
}
2920

    
2921
static int opt_audio_channels(const char *opt, const char *arg)
2922
{
2923
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2924
    return 0;
2925
}
2926

    
2927
static void opt_video_channel(const char *arg)
2928
{
2929
    video_channel = strtol(arg, NULL, 0);
2930
}
2931

    
2932
static void opt_video_standard(const char *arg)
2933
{
2934
    video_standard = av_strdup(arg);
2935
}
2936

    
2937
static void opt_codec(int *pstream_copy, char **pcodec_name,
2938
                      int codec_type, const char *arg)
2939
{
2940
    av_freep(pcodec_name);
2941
    if (!strcmp(arg, "copy")) {
2942
        *pstream_copy = 1;
2943
    } else {
2944
        *pcodec_name = av_strdup(arg);
2945
    }
2946
}
2947

    
2948
static void opt_audio_codec(const char *arg)
2949
{
2950
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2951
}
2952

    
2953
static void opt_video_codec(const char *arg)
2954
{
2955
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2956
}
2957

    
2958
static void opt_subtitle_codec(const char *arg)
2959
{
2960
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2961
}
2962

    
2963
static int opt_codec_tag(const char *opt, const char *arg)
2964
{
2965
    char *tail;
2966
    uint32_t *codec_tag;
2967

    
2968
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2969
                !strcmp(opt, "vtag") ? &video_codec_tag :
2970
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2971
    if (!codec_tag)
2972
        return -1;
2973

    
2974
    *codec_tag = strtol(arg, &tail, 0);
2975
    if (!tail || *tail)
2976
        *codec_tag = AV_RL32(arg);
2977

    
2978
    return 0;
2979
}
2980

    
2981
static void opt_map(const char *arg)
2982
{
2983
    AVStreamMap *m;
2984
    char *p;
2985

    
2986
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2987
    m = &stream_maps[nb_stream_maps-1];
2988

    
2989
    m->file_index = strtol(arg, &p, 0);
2990
    if (*p)
2991
        p++;
2992

    
2993
    m->stream_index = strtol(p, &p, 0);
2994
    if (*p) {
2995
        p++;
2996
        m->sync_file_index = strtol(p, &p, 0);
2997
        if (*p)
2998
            p++;
2999
        m->sync_stream_index = strtol(p, &p, 0);
3000
    } else {
3001
        m->sync_file_index = m->file_index;
3002
        m->sync_stream_index = m->stream_index;
3003
    }
3004
}
3005

    
3006
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3007
{
3008
    *endptr = arg;
3009
    if (*arg == ',') {
3010
        *type = *(++arg);
3011
        switch (*arg) {
3012
        case 'g':
3013
            break;
3014
        case 's':
3015
        case 'c':
3016
        case 'p':
3017
            *index = strtol(++arg, endptr, 0);
3018
            break;
3019
        default:
3020
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3021
            ffmpeg_exit(1);
3022
        }
3023
    } else
3024
        *type = 'g';
3025
}
3026

    
3027
static void opt_map_metadata(const char *arg)
3028
{
3029
    AVMetaDataMap *m, *m1;
3030
    char *p;
3031

    
3032
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3033
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3034

    
3035
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3036
    m->file = strtol(arg, &p, 0);
3037
    parse_meta_type(p, &m->type, &m->index, &p);
3038
    if (*p)
3039
        p++;
3040

    
3041
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3042
    m1->file = strtol(p, &p, 0);
3043
    parse_meta_type(p, &m1->type, &m1->index, &p);
3044

    
3045
    if (m->type == 'g' || m1->type == 'g')
3046
        metadata_global_autocopy = 0;
3047
    if (m->type == 's' || m1->type == 's')
3048
        metadata_streams_autocopy = 0;
3049
    if (m->type == 'c' || m1->type == 'c')
3050
        metadata_chapters_autocopy = 0;
3051
}
3052

    
3053
static void opt_map_meta_data(const char *arg)
3054
{
3055
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3056
                    "Use -map_metadata instead.\n");
3057
    opt_map_metadata(arg);
3058
}
3059

    
3060
static void opt_map_chapters(const char *arg)
3061
{
3062
    AVChapterMap *c;
3063
    char *p;
3064

    
3065
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3066
                              nb_chapter_maps + 1);
3067
    c = &chapter_maps[nb_chapter_maps - 1];
3068
    c->out_file = strtol(arg, &p, 0);
3069
    if (*p)
3070
        p++;
3071

    
3072
    c->in_file = strtol(p, &p, 0);
3073
}
3074

    
3075
static void opt_input_ts_scale(const char *arg)
3076
{
3077
    unsigned int stream;
3078
    double scale;
3079
    char *p;
3080

    
3081
    stream = strtol(arg, &p, 0);
3082
    if (*p)
3083
        p++;
3084
    scale= strtod(p, &p);
3085

    
3086
    if(stream >= MAX_STREAMS)
3087
        ffmpeg_exit(1);
3088

    
3089
    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);
3090
    input_files_ts_scale[nb_input_files][stream]= scale;
3091
}
3092

    
3093
static int opt_recording_time(const char *opt, const char *arg)
3094
{
3095
    recording_time = parse_time_or_die(opt, arg, 1);
3096
    return 0;
3097
}
3098

    
3099
static int opt_start_time(const char *opt, const char *arg)
3100
{
3101
    start_time = parse_time_or_die(opt, arg, 1);
3102
    return 0;
3103
}
3104

    
3105
static int opt_recording_timestamp(const char *opt, const char *arg)
3106
{
3107
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3108
    return 0;
3109
}
3110

    
3111
static int opt_input_ts_offset(const char *opt, const char *arg)
3112
{
3113
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3114
    return 0;
3115
}
3116

    
3117
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3118
{
3119
    const char *codec_string = encoder ? "encoder" : "decoder";
3120
    AVCodec *codec;
3121

    
3122
    if(!name)
3123
        return CODEC_ID_NONE;
3124
    codec = encoder ?
3125
        avcodec_find_encoder_by_name(name) :
3126
        avcodec_find_decoder_by_name(name);
3127
    if(!codec) {
3128
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3129
        ffmpeg_exit(1);
3130
    }
3131
    if(codec->type != type) {
3132
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3133
        ffmpeg_exit(1);
3134
    }
3135
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3136
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3137
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3138
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3139
                codec_string, codec->name);
3140
        codec = encoder ?
3141
            avcodec_find_encoder(codec->id) :
3142
            avcodec_find_decoder(codec->id);
3143
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3144
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3145
                    codec_string, codec->name);
3146
        ffmpeg_exit(1);
3147
    }
3148
    return codec->id;
3149
}
3150

    
3151
static void opt_input_file(const char *filename)
3152
{
3153
    AVFormatContext *ic;
3154
    AVFormatParameters params, *ap = &params;
3155
    AVInputFormat *file_iformat = NULL;
3156
    int err, i, ret, rfps, rfps_base;
3157
    int64_t timestamp;
3158

    
3159
    if (last_asked_format) {
3160
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3161
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3162
            ffmpeg_exit(1);
3163
        }
3164
        last_asked_format = NULL;
3165
    }
3166

    
3167
    if (!strcmp(filename, "-"))
3168
        filename = "pipe:";
3169

    
3170
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3171
                    !strcmp(filename, "/dev/stdin");
3172

    
3173
    /* get default parameters from command line */
3174
    ic = avformat_alloc_context();
3175
    if (!ic) {
3176
        print_error(filename, AVERROR(ENOMEM));
3177
        ffmpeg_exit(1);
3178
    }
3179

    
3180
    memset(ap, 0, sizeof(*ap));
3181
    ap->prealloced_context = 1;
3182
    ap->sample_rate = audio_sample_rate;
3183
    ap->channels = audio_channels;
3184
    ap->time_base.den = frame_rate.num;
3185
    ap->time_base.num = frame_rate.den;
3186
    ap->width = frame_width;
3187
    ap->height = frame_height;
3188
    ap->pix_fmt = frame_pix_fmt;
3189
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3190
    ap->channel = video_channel;
3191
    ap->standard = video_standard;
3192

    
3193
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3194

    
3195
    ic->video_codec_id   =
3196
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3197
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3198
    ic->audio_codec_id   =
3199
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3200
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3201
    ic->subtitle_codec_id=
3202
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3203
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3204
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3205

    
3206
    /* open the input file with generic libav function */
3207
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3208
    if (err < 0) {
3209
        print_error(filename, err);
3210
        ffmpeg_exit(1);
3211
    }
3212
    if(opt_programid) {
3213
        int i, j;
3214
        int found=0;
3215
        for(i=0; i<ic->nb_streams; i++){
3216
            ic->streams[i]->discard= AVDISCARD_ALL;
3217
        }
3218
        for(i=0; i<ic->nb_programs; i++){
3219
            AVProgram *p= ic->programs[i];
3220
            if(p->id != opt_programid){
3221
                p->discard = AVDISCARD_ALL;
3222
            }else{
3223
                found=1;
3224
                for(j=0; j<p->nb_stream_indexes; j++){
3225
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3226
                }
3227
            }
3228
        }
3229
        if(!found){
3230
            fprintf(stderr, "Specified program id not found\n");
3231
            ffmpeg_exit(1);
3232
        }
3233
        opt_programid=0;
3234
    }
3235

    
3236
    ic->loop_input = loop_input;
3237

    
3238
    /* If not enough info to get the stream parameters, we decode the
3239
       first frames to get it. (used in mpeg case for example) */
3240
    ret = av_find_stream_info(ic);
3241
    if (ret < 0 && verbose >= 0) {
3242
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3243
        av_close_input_file(ic);
3244
        ffmpeg_exit(1);
3245
    }
3246

    
3247
    timestamp = start_time;
3248
    /* add the stream start time */
3249
    if (ic->start_time != AV_NOPTS_VALUE)
3250
        timestamp += ic->start_time;
3251

    
3252
    /* if seeking requested, we execute it */
3253
    if (start_time != 0) {
3254
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3255
        if (ret < 0) {
3256
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3257
                    filename, (double)timestamp / AV_TIME_BASE);
3258
        }
3259
        /* reset seek info */
3260
        start_time = 0;
3261
    }
3262

    
3263
    /* update the current parameters so that they match the one of the input stream */
3264
    for(i=0;i<ic->nb_streams;i++) {
3265
        AVStream *st = ic->streams[i];
3266
        AVCodecContext *dec = st->codec;
3267
        dec->thread_count = thread_count;
3268
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3269
        switch (dec->codec_type) {
3270
        case AVMEDIA_TYPE_AUDIO:
3271
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3272
            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]);
3273
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3274
            channel_layout    = dec->channel_layout;
3275
            audio_channels    = dec->channels;
3276
            audio_sample_rate = dec->sample_rate;
3277
            audio_sample_fmt  = dec->sample_fmt;
3278
            if(audio_disable)
3279
                st->discard= AVDISCARD_ALL;
3280
            /* Note that av_find_stream_info can add more streams, and we
3281
             * currently have no chance of setting up lowres decoding
3282
             * early enough for them. */
3283
            if (dec->lowres)
3284
                audio_sample_rate >>= dec->lowres;
3285
            break;
3286
        case AVMEDIA_TYPE_VIDEO:
3287
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3288
            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]);
3289
            frame_height = dec->height;
3290
            frame_width  = dec->width;
3291
            if(ic->streams[i]->sample_aspect_ratio.num)
3292
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3293
            else
3294
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3295
            frame_aspect_ratio *= (float) dec->width / dec->height;
3296
            frame_pix_fmt = dec->pix_fmt;
3297
            rfps      = ic->streams[i]->r_frame_rate.num;
3298
            rfps_base = ic->streams[i]->r_frame_rate.den;
3299
            if (dec->lowres) {
3300
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3301
                frame_height >>= dec->lowres;
3302
                frame_width  >>= dec->lowres;
3303
                dec->height = frame_height;
3304
                dec->width  = frame_width;
3305
            }
3306
            if(me_threshold)
3307
                dec->debug |= FF_DEBUG_MV;
3308

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

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

    
3315
                    (float)rfps / rfps_base, rfps, rfps_base);
3316
            }
3317
            /* update the current frame rate to match the stream frame rate */
3318
            frame_rate.num = rfps;
3319
            frame_rate.den = rfps_base;
3320

    
3321
            if(video_disable)
3322
                st->discard= AVDISCARD_ALL;
3323
            else if(video_discard)
3324
                st->discard= video_discard;
3325
            break;
3326
        case AVMEDIA_TYPE_DATA:
3327
            break;
3328
        case AVMEDIA_TYPE_SUBTITLE:
3329
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3330
            if(subtitle_disable)
3331
                st->discard = AVDISCARD_ALL;
3332
            break;
3333
        case AVMEDIA_TYPE_ATTACHMENT:
3334
        case AVMEDIA_TYPE_UNKNOWN:
3335
            break;
3336
        default:
3337
            abort();
3338
        }
3339
    }
3340

    
3341
    input_files[nb_input_files] = ic;
3342
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3343
    /* dump the file content */
3344
    if (verbose >= 0)
3345
        av_dump_format(ic, nb_input_files, filename, 0);
3346

    
3347
    nb_input_files++;
3348

    
3349
    video_channel = 0;
3350

    
3351
    av_freep(&video_codec_name);
3352
    av_freep(&audio_codec_name);
3353
    av_freep(&subtitle_codec_name);
3354
}
3355

    
3356
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3357
                                         int *has_subtitle_ptr)
3358
{
3359
    int has_video, has_audio, has_subtitle, i, j;
3360
    AVFormatContext *ic;
3361

    
3362
    has_video = 0;
3363
    has_audio = 0;
3364
    has_subtitle = 0;
3365
    for(j=0;j<nb_input_files;j++) {
3366
        ic = input_files[j];
3367
        for(i=0;i<ic->nb_streams;i++) {
3368
            AVCodecContext *enc = ic->streams[i]->codec;
3369
            switch(enc->codec_type) {
3370
            case AVMEDIA_TYPE_AUDIO:
3371
                has_audio = 1;
3372
                break;
3373
            case AVMEDIA_TYPE_VIDEO:
3374
                has_video = 1;
3375
                break;
3376
            case AVMEDIA_TYPE_SUBTITLE:
3377
                has_subtitle = 1;
3378
                break;
3379
            case AVMEDIA_TYPE_DATA:
3380
            case AVMEDIA_TYPE_ATTACHMENT:
3381
            case AVMEDIA_TYPE_UNKNOWN:
3382
                break;
3383
            default:
3384
                abort();
3385
            }
3386
        }
3387
    }
3388
    *has_video_ptr = has_video;
3389
    *has_audio_ptr = has_audio;
3390
    *has_subtitle_ptr = has_subtitle;
3391
}
3392

    
3393
static void new_video_stream(AVFormatContext *oc, int file_idx)
3394
{
3395
    AVStream *st;
3396
    AVOutputStream *ost;
3397
    AVCodecContext *video_enc;
3398
    enum CodecID codec_id = CODEC_ID_NONE;
3399
    AVCodec *codec= NULL;
3400
    int i;
3401

    
3402
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3403
    if (!st) {
3404
        fprintf(stderr, "Could not alloc stream\n");
3405
        ffmpeg_exit(1);
3406
    }
3407
    ost = new_output_stream(oc, file_idx);
3408

    
3409
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3410
    if(!video_stream_copy){
3411
        if (video_codec_name) {
3412
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3413
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3414
            codec = avcodec_find_encoder_by_name(video_codec_name);
3415
            output_codecs[nb_output_codecs-1] = codec;
3416
        } else {
3417
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3418
            codec = avcodec_find_encoder(codec_id);
3419
        }
3420
#if CONFIG_AVFILTER
3421
        if(frame_aspect_ratio > 0){
3422
            char *tmp;
3423
            i = vfilters ? strlen(vfilters) : 0;
3424
            tmp= av_malloc(i+100);
3425
            snprintf(tmp, i+100, "setdar=%f%c%s\n", frame_aspect_ratio, i?',':' ', vfilters ? vfilters : "");
3426
            av_freep(&vfilters);
3427
            vfilters= tmp;
3428
            frame_aspect_ratio=0;
3429
        }
3430

    
3431
        ost->avfilter= vfilters;
3432
        vfilters= NULL;
3433
#endif
3434
    }
3435

    
3436
    avcodec_get_context_defaults3(st->codec, codec);
3437
    ost->bitstream_filters = video_bitstream_filters;
3438
    video_bitstream_filters= NULL;
3439

    
3440
    st->codec->thread_count= thread_count;
3441

    
3442
    video_enc = st->codec;
3443

    
3444
    if(video_codec_tag)
3445
        video_enc->codec_tag= video_codec_tag;
3446

    
3447
    if(   (video_global_header&1)
3448
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3449
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3450
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3451
    }
3452
    if(video_global_header&2){
3453
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3454
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3455
    }
3456

    
3457
    if (video_stream_copy) {
3458
        st->stream_copy = 1;
3459
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3460
        video_enc->sample_aspect_ratio =
3461
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3462
    } else {
3463
        const char *p;
3464
        int i;
3465
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3466

    
3467
        video_enc->codec_id = codec_id;
3468
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3469

    
3470
        if (codec && codec->supported_framerates && !force_fps)
3471
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3472
        video_enc->time_base.den = fps.num;
3473
        video_enc->time_base.num = fps.den;
3474

    
3475
        video_enc->width = frame_width;
3476
        video_enc->height = frame_height;
3477
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3478
        video_enc->pix_fmt = frame_pix_fmt;
3479
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3480

    
3481
        choose_pixel_fmt(st, codec);
3482

    
3483
        if (intra_only)
3484
            video_enc->gop_size = 0;
3485
        if (video_qscale || same_quality) {
3486
            video_enc->flags |= CODEC_FLAG_QSCALE;
3487
            video_enc->global_quality=
3488
                st->quality = FF_QP2LAMBDA * video_qscale;
3489
        }
3490

    
3491
        if(intra_matrix)
3492
            video_enc->intra_matrix = intra_matrix;
3493
        if(inter_matrix)
3494
            video_enc->inter_matrix = inter_matrix;
3495

    
3496
        p= video_rc_override_string;
3497
        for(i=0; p; i++){
3498
            int start, end, q;
3499
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3500
            if(e!=3){
3501
                fprintf(stderr, "error parsing rc_override\n");
3502
                ffmpeg_exit(1);
3503
            }
3504
            video_enc->rc_override=
3505
                av_realloc(video_enc->rc_override,
3506
                           sizeof(RcOverride)*(i+1));
3507
            video_enc->rc_override[i].start_frame= start;
3508
            video_enc->rc_override[i].end_frame  = end;
3509
            if(q>0){
3510
                video_enc->rc_override[i].qscale= q;
3511
                video_enc->rc_override[i].quality_factor= 1.0;
3512
            }
3513
            else{
3514
                video_enc->rc_override[i].qscale= 0;
3515
                video_enc->rc_override[i].quality_factor= -q/100.0;
3516
            }
3517
            p= strchr(p, '/');
3518
            if(p) p++;
3519
        }
3520
        video_enc->rc_override_count=i;
3521
        if (!video_enc->rc_initial_buffer_occupancy)
3522
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3523
        video_enc->me_threshold= me_threshold;
3524
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3525

    
3526
        if (do_psnr)
3527
            video_enc->flags|= CODEC_FLAG_PSNR;
3528

    
3529
        /* two pass mode */
3530
        if (do_pass) {
3531
            if (do_pass == 1) {
3532
                video_enc->flags |= CODEC_FLAG_PASS1;
3533
            } else {
3534
                video_enc->flags |= CODEC_FLAG_PASS2;
3535
            }
3536
        }
3537

    
3538
        if (forced_key_frames)
3539
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3540
    }
3541
    if (video_language) {
3542
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3543
        av_freep(&video_language);
3544
    }
3545

    
3546
    /* reset some key parameters */
3547
    video_disable = 0;
3548
    av_freep(&video_codec_name);
3549
    av_freep(&forced_key_frames);
3550
    video_stream_copy = 0;
3551
    frame_pix_fmt = PIX_FMT_NONE;
3552
}
3553

    
3554
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3555
{
3556
    AVStream *st;
3557
    AVOutputStream *ost;
3558
    AVCodec *codec= NULL;
3559
    AVCodecContext *audio_enc;
3560
    enum CodecID codec_id = CODEC_ID_NONE;
3561

    
3562
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3563
    if (!st) {
3564
        fprintf(stderr, "Could not alloc stream\n");
3565
        ffmpeg_exit(1);
3566
    }
3567
    ost = new_output_stream(oc, file_idx);
3568

    
3569
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3570
    if(!audio_stream_copy){
3571
        if (audio_codec_name) {
3572
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3573
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3574
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3575
            output_codecs[nb_output_codecs-1] = codec;
3576
        } else {
3577
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3578
            codec = avcodec_find_encoder(codec_id);
3579
        }
3580
    }
3581

    
3582
    avcodec_get_context_defaults3(st->codec, codec);
3583

    
3584
    ost->bitstream_filters = audio_bitstream_filters;
3585
    audio_bitstream_filters= NULL;
3586

    
3587
    st->codec->thread_count= thread_count;
3588

    
3589
    audio_enc = st->codec;
3590
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3591

    
3592
    if(audio_codec_tag)
3593
        audio_enc->codec_tag= audio_codec_tag;
3594

    
3595
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3596
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3597
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3598
    }
3599
    if (audio_stream_copy) {
3600
        st->stream_copy = 1;
3601
        audio_enc->channels = audio_channels;
3602
        audio_enc->sample_rate = audio_sample_rate;
3603
    } else {
3604
        audio_enc->codec_id = codec_id;
3605
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3606

    
3607
        if (audio_qscale > QSCALE_NONE) {
3608
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3609
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3610
        }
3611
        audio_enc->channels = audio_channels;
3612
        audio_enc->sample_fmt = audio_sample_fmt;
3613
        audio_enc->sample_rate = audio_sample_rate;
3614
        audio_enc->channel_layout = channel_layout;
3615
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3616
            audio_enc->channel_layout = 0;
3617
        choose_sample_fmt(st, codec);
3618
        choose_sample_rate(st, codec);
3619
    }
3620
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3621
    if (audio_language) {
3622
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3623
        av_freep(&audio_language);
3624
    }
3625

    
3626
    /* reset some key parameters */
3627
    audio_disable = 0;
3628
    av_freep(&audio_codec_name);
3629
    audio_stream_copy = 0;
3630
}
3631

    
3632
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3633
{
3634
    AVStream *st;
3635
    AVOutputStream *ost;
3636
    AVCodec *codec=NULL;
3637
    AVCodecContext *subtitle_enc;
3638
    enum CodecID codec_id = CODEC_ID_NONE;
3639

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

    
3660
    ost->bitstream_filters = subtitle_bitstream_filters;
3661
    subtitle_bitstream_filters= NULL;
3662

    
3663
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3664

    
3665
    if(subtitle_codec_tag)
3666
        subtitle_enc->codec_tag= subtitle_codec_tag;
3667

    
3668
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3669
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3670
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3671
    }
3672
    if (subtitle_stream_copy) {
3673
        st->stream_copy = 1;
3674
    } else {
3675
        subtitle_enc->codec_id = codec_id;
3676
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3677
    }
3678

    
3679
    if (subtitle_language) {
3680
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3681
        av_freep(&subtitle_language);
3682
    }
3683

    
3684
    subtitle_disable = 0;
3685
    av_freep(&subtitle_codec_name);
3686
    subtitle_stream_copy = 0;
3687
}
3688

    
3689
static int opt_new_stream(const char *opt, const char *arg)
3690
{
3691
    AVFormatContext *oc;
3692
    int file_idx = nb_output_files - 1;
3693
    if (nb_output_files <= 0) {
3694
        fprintf(stderr, "At least one output file must be specified\n");
3695
        ffmpeg_exit(1);
3696
    }
3697
    oc = output_files[file_idx];
3698

    
3699
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3700
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3701
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3702
    else av_assert0(0);
3703
    return 0;
3704
}
3705

    
3706
/* arg format is "output-stream-index:streamid-value". */
3707
static int opt_streamid(const char *opt, const char *arg)
3708
{
3709
    int idx;
3710
    char *p;
3711
    char idx_str[16];
3712

    
3713
    strncpy(idx_str, arg, sizeof(idx_str));
3714
    idx_str[sizeof(idx_str)-1] = '\0';
3715
    p = strchr(idx_str, ':');
3716
    if (!p) {
3717
        fprintf(stderr,
3718
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3719
                arg, opt);
3720
        ffmpeg_exit(1);
3721
    }
3722
    *p++ = '\0';
3723
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3724
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3725
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3726
    return 0;
3727
}
3728

    
3729
static void opt_output_file(const char *filename)
3730
{
3731
    AVFormatContext *oc;
3732
    int err, use_video, use_audio, use_subtitle;
3733
    int input_has_video, input_has_audio, input_has_subtitle;
3734
    AVFormatParameters params, *ap = &params;
3735
    AVOutputFormat *file_oformat;
3736

    
3737
    if (!strcmp(filename, "-"))
3738
        filename = "pipe:";
3739

    
3740
    oc = avformat_alloc_context();
3741
    if (!oc) {
3742
        print_error(filename, AVERROR(ENOMEM));
3743
        ffmpeg_exit(1);
3744
    }
3745

    
3746
    if (last_asked_format) {
3747
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3748
        if (!file_oformat) {
3749
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3750
            ffmpeg_exit(1);
3751
        }
3752
        last_asked_format = NULL;
3753
    } else {
3754
        file_oformat = av_guess_format(NULL, filename, NULL);
3755
        if (!file_oformat) {
3756
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3757
                    filename);
3758
            ffmpeg_exit(1);
3759
        }
3760
    }
3761

    
3762
    oc->oformat = file_oformat;
3763
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3764

    
3765
    if (!strcmp(file_oformat->name, "ffm") &&
3766
        av_strstart(filename, "http:", NULL)) {
3767
        /* special case for files sent to ffserver: we get the stream
3768
           parameters from ffserver */
3769
        int err = read_ffserver_streams(oc, filename);
3770
        if (err < 0) {
3771
            print_error(filename, err);
3772
            ffmpeg_exit(1);
3773
        }
3774
    } else {
3775
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3776
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3777
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3778

    
3779
        /* disable if no corresponding type found and at least one
3780
           input file */
3781
        if (nb_input_files > 0) {
3782
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3783
                                         &input_has_subtitle);
3784
            if (!input_has_video)
3785
                use_video = 0;
3786
            if (!input_has_audio)
3787
                use_audio = 0;
3788
            if (!input_has_subtitle)
3789
                use_subtitle = 0;
3790
        }
3791

    
3792
        /* manual disable */
3793
        if (audio_disable)    use_audio    = 0;
3794
        if (video_disable)    use_video    = 0;
3795
        if (subtitle_disable) use_subtitle = 0;
3796

    
3797
        if (use_video)    new_video_stream(oc, nb_output_files);
3798
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3799
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3800

    
3801
        oc->timestamp = recording_timestamp;
3802

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

    
3807
    output_files[nb_output_files++] = oc;
3808

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

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

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

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

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

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

    
3859
    av_freep(&forced_key_frames);
3860
}
3861

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4000
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4001
}
4002

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

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

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

    
4059
    if(!strcmp(arg, "vcd")) {
4060

    
4061
        opt_video_codec("mpeg1video");
4062
        opt_audio_codec("mp2");
4063
        opt_format("vcd");
4064

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

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

    
4074
        opt_default("ab", "224000");
4075
        audio_sample_rate = 44100;
4076
        audio_channels = 2;
4077

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

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

    
4089
        opt_video_codec("mpeg2video");
4090
        opt_audio_codec("mp2");
4091
        opt_format("svcd");
4092

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

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

    
4103

    
4104
        opt_default("ab", "224000");
4105
        audio_sample_rate = 44100;
4106

    
4107
        opt_default("packetsize", "2324");
4108

    
4109
    } else if(!strcmp(arg, "dvd")) {
4110

    
4111
        opt_video_codec("mpeg2video");
4112
        opt_audio_codec("ac3");
4113
        opt_format("dvd");
4114

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

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

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

    
4127
        opt_default("ab", "448000");
4128
        audio_sample_rate = 48000;
4129

    
4130
    } else if(!strncmp(arg, "dv", 2)) {
4131

    
4132
        opt_format("dv");
4133

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

    
4139
        audio_sample_rate = 48000;
4140
        audio_channels = 2;
4141

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

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

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

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

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

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

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

    
4181
    *bsfp= bsfc;
4182

    
4183
    return 0;
4184
}
4185

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

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

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

    
4220
    fclose(f);
4221

    
4222
    return 0;
4223
}
4224

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

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

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

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

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

    
4344
    /* muxer options */
4345
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4346
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4347

    
4348
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4349
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4350
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4351

    
4352
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4353
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4354
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4355
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4356

    
4357
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4358
    { NULL, },
4359
};
4360

    
4361
int main(int argc, char **argv)
4362
{
4363
    int64_t ti;
4364

    
4365
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4366

    
4367
    avcodec_register_all();
4368
#if CONFIG_AVDEVICE
4369
    avdevice_register_all();
4370
#endif
4371
#if CONFIG_AVFILTER
4372
    avfilter_register_all();
4373
#endif
4374
    av_register_all();
4375

    
4376
#if HAVE_ISATTY
4377
    if(isatty(STDIN_FILENO))
4378
        url_set_interrupt_cb(decode_interrupt_cb);
4379
#endif
4380

    
4381
    init_opts();
4382

    
4383
    show_banner();
4384

    
4385
    /* parse options */
4386
    parse_options(argc, argv, options, opt_output_file);
4387

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

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

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

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

    
4415
    return ffmpeg_exit(0);
4416
}