Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ abf8342a

History | View | Annotate | Download (163 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
#include "libavformat/ffm.h" // not public API
51

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

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

    
70
#if HAVE_SYS_SELECT_H
71
#include <sys/select.h>
72
#endif
73

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

    
84
#include "cmdutils.h"
85

    
86
#include "libavutil/avassert.h"
87

    
88
const char program_name[] = "FFmpeg";
89
const int program_birth_year = 2000;
90

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

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

    
108
typedef struct AVChapterMap {
109
    int in_file;
110
    int out_file;
111
} AVChapterMap;
112

    
113
static const OptionDef options[];
114

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

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

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

    
134
static AVStreamMap *stream_maps = NULL;
135
static int nb_stream_maps;
136

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

    
144
static AVChapterMap *chapter_maps = NULL;
145
static int nb_chapter_maps;
146

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

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

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

    
193
static int subtitle_disable = 0;
194
static char *subtitle_codec_name = NULL;
195
static char *subtitle_language = NULL;
196
static unsigned int subtitle_codec_tag = 0;
197

    
198
static float mux_preload= 0.5;
199
static float mux_max_delay= 0.7;
200

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

    
228
static int rate_emu = 0;
229

    
230
static int  video_channel = 0;
231
static char *video_standard;
232

    
233
static int audio_volume = 256;
234

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

    
250
static float dts_delta_threshold = 10;
251

    
252
static int64_t timer_start;
253

    
254
static uint8_t *audio_buf;
255
static uint8_t *audio_out;
256
static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
257

    
258
static short *samples;
259

    
260
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
261
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
262
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
263

    
264
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
265

    
266
struct AVInputStream;
267

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

    
289
    float frame_aspect_ratio;
290

    
291
    /* full frame size of first frame */
292
    int original_height;
293
    int original_width;
294

    
295
    /* forced key frames */
296
    int64_t *forced_kf_pts;
297
    int forced_kf_count;
298
    int forced_kf_index;
299

    
300
    /* audio only */
301
    int audio_resample;
302
    ReSampleContext *resample; /* for audio resampling */
303
    int resample_sample_fmt;
304
    int resample_channels;
305
    int resample_sample_rate;
306
    int reformat_pair;
307
    AVAudioConvert *reformat_ctx;
308
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
309
    FILE *logfile;
310

    
311
#if CONFIG_AVFILTER
312
    AVFilterContext *output_video_filter;
313
    AVFilterContext *input_video_filter;
314
    AVFilterBufferRef *picref;
315
    char *avfilter;
316
    AVFilterGraph *graph;
317
#endif
318
} AVOutputStream;
319

    
320
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
321
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
322

    
323
typedef struct AVInputStream {
324
    int file_index;
325
    int index;
326
    AVStream *st;
327
    int discard;             /* true if stream data should be discarded */
328
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
329
    int64_t sample_index;      /* current sample */
330

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

    
344
typedef struct AVInputFile {
345
    int eof_reached;      /* true if eof reached */
346
    int ist_index;        /* index of first stream in ist_table */
347
    int buffer_size;      /* current total buffer size */
348
    int nb_streams;       /* nb streams we are aware of */
349
} AVInputFile;
350

    
351
#if HAVE_TERMIOS_H
352

    
353
/* init terminal so that we can grab keys */
354
static struct termios oldtty;
355
#endif
356

    
357
#if CONFIG_AVFILTER
358

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

    
370
    ost->graph = avfilter_graph_alloc();
371

    
372
    if (ist->st->sample_aspect_ratio.num){
373
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
374
    }else
375
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
376

    
377
    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
378
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
379
             sample_aspect_ratio.num, sample_aspect_ratio.den);
380

    
381
    ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
382
                                       "src", args, NULL, ost->graph);
383
    if (ret < 0)
384
        return ret;
385
    ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
386
                                       "out", NULL, &ffsink_ctx, ost->graph);
387
    if (ret < 0)
388
        return ret;
389
    last_filter = ost->input_video_filter;
390

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

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

    
407
    if (ost->avfilter) {
408
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
409
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
410

    
411
        outputs->name    = av_strdup("in");
412
        outputs->filter_ctx = last_filter;
413
        outputs->pad_idx = 0;
414
        outputs->next    = NULL;
415

    
416
        inputs->name    = av_strdup("out");
417
        inputs->filter_ctx = ost->output_video_filter;
418
        inputs->pad_idx = 0;
419
        inputs->next    = NULL;
420

    
421
        if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
422
            return ret;
423
        av_freep(&ost->avfilter);
424
    } else {
425
        if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
426
            return ret;
427
    }
428

    
429
    if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
430
        return ret;
431

    
432
    codec->width  = ost->output_video_filter->inputs[0]->w;
433
    codec->height = ost->output_video_filter->inputs[0]->h;
434
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
435
        ost->frame_aspect_ratio ? // overriden by the -aspect cli option
436
        av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
437
        ost->output_video_filter->inputs[0]->sample_aspect_ratio;
438

    
439
    return 0;
440
}
441
#endif /* CONFIG_AVFILTER */
442

    
443
static void term_exit(void)
444
{
445
    av_log(NULL, AV_LOG_QUIET, "");
446
#if HAVE_TERMIOS_H
447
    tcsetattr (0, TCSANOW, &oldtty);
448
#endif
449
}
450

    
451
static volatile int received_sigterm = 0;
452

    
453
static void
454
sigterm_handler(int sig)
455
{
456
    received_sigterm = sig;
457
    q_pressed++;
458
    term_exit();
459
}
460

    
461
static void term_init(void)
462
{
463
#if HAVE_TERMIOS_H
464
    struct termios tty;
465

    
466
    tcgetattr (0, &tty);
467
    oldtty = tty;
468
    atexit(term_exit);
469

    
470
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
471
                          |INLCR|IGNCR|ICRNL|IXON);
472
    tty.c_oflag |= OPOST;
473
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
474
    tty.c_cflag &= ~(CSIZE|PARENB);
475
    tty.c_cflag |= CS8;
476
    tty.c_cc[VMIN] = 1;
477
    tty.c_cc[VTIME] = 0;
478

    
479
    tcsetattr (0, TCSANOW, &tty);
480
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
481
#endif
482

    
483
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
484
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
485
#ifdef SIGXCPU
486
    signal(SIGXCPU, sigterm_handler);
487
#endif
488
}
489

    
490
/* read a key without blocking */
491
static int read_key(void)
492
{
493
#if HAVE_TERMIOS_H
494
    int n = 1;
495
    unsigned char ch;
496
    struct timeval tv;
497
    fd_set rfds;
498

    
499
    FD_ZERO(&rfds);
500
    FD_SET(0, &rfds);
501
    tv.tv_sec = 0;
502
    tv.tv_usec = 0;
503
    n = select(1, &rfds, NULL, NULL, &tv);
504
    if (n > 0) {
505
        n = read(0, &ch, 1);
506
        if (n == 1)
507
            return ch;
508

    
509
        return n;
510
    }
511
#elif HAVE_KBHIT
512
    if(kbhit())
513
        return(getch());
514
#endif
515
    return -1;
516
}
517

    
518
static int decode_interrupt_cb(void)
519
{
520
    q_pressed += read_key() == 'q';
521
    return q_pressed > 1;
522
}
523

    
524
static int ffmpeg_exit(int ret)
525
{
526
    int i;
527

    
528
    /* close files */
529
    for(i=0;i<nb_output_files;i++) {
530
        AVFormatContext *s = output_files[i];
531
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
532
            avio_close(s->pb);
533
        avformat_free_context(s);
534
        av_free(output_streams_for_file[i]);
535
    }
536
    for(i=0;i<nb_input_files;i++) {
537
        av_close_input_file(input_files[i]);
538
        av_free(input_files_ts_scale[i]);
539
    }
540

    
541
    av_free(intra_matrix);
542
    av_free(inter_matrix);
543

    
544
    if (vstats_file)
545
        fclose(vstats_file);
546
    av_free(vstats_filename);
547

    
548
    av_free(streamid_map);
549
    av_free(input_codecs);
550
    av_free(output_codecs);
551
    av_free(stream_maps);
552
    av_free(meta_data_maps);
553

    
554
    av_free(video_codec_name);
555
    av_free(audio_codec_name);
556
    av_free(subtitle_codec_name);
557

    
558
    av_free(video_standard);
559

    
560
    uninit_opts();
561
    av_free(audio_buf);
562
    av_free(audio_out);
563
    allocated_audio_buf_size= allocated_audio_out_size= 0;
564
    av_free(samples);
565

    
566
#if CONFIG_AVFILTER
567
    avfilter_uninit();
568
#endif
569

    
570
    if (received_sigterm) {
571
        fprintf(stderr,
572
            "Received signal %d: terminating.\n",
573
            (int) received_sigterm);
574
        exit (255);
575
    }
576

    
577
    exit(ret); /* not all OS-es handle main() return value */
578
    return ret;
579
}
580

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

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

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

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

    
667
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
668
{
669
    int idx = oc->nb_streams - 1;
670
    AVOutputStream *ost;
671

    
672
    output_streams_for_file[file_idx] =
673
        grow_array(output_streams_for_file[file_idx],
674
                   sizeof(*output_streams_for_file[file_idx]),
675
                   &nb_output_streams_for_file[file_idx],
676
                   oc->nb_streams);
677
    ost = output_streams_for_file[file_idx][idx] =
678
        av_mallocz(sizeof(AVOutputStream));
679
    if (!ost) {
680
        fprintf(stderr, "Could not alloc output stream\n");
681
        ffmpeg_exit(1);
682
    }
683
    ost->file_index = file_idx;
684
    ost->index = idx;
685
    return ost;
686
}
687

    
688
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
689
{
690
    int i, err;
691
    AVFormatContext *ic;
692
    int nopts = 0;
693

    
694
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
695
    if (err < 0)
696
        return err;
697
    /* copy stream format */
698
    s->nb_streams = 0;
699
    for(i=0;i<ic->nb_streams;i++) {
700
        AVStream *st;
701
        AVCodec *codec;
702

    
703
        s->nb_streams++;
704

    
705
        // FIXME: a more elegant solution is needed
706
        st = av_mallocz(sizeof(AVStream));
707
        memcpy(st, ic->streams[i], sizeof(AVStream));
708
        st->codec = avcodec_alloc_context();
709
        if (!st->codec) {
710
            print_error(filename, AVERROR(ENOMEM));
711
            ffmpeg_exit(1);
712
        }
713
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
714
        s->streams[i] = st;
715

    
716
        codec = avcodec_find_encoder(st->codec->codec_id);
717
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
718
            if (audio_stream_copy) {
719
                st->stream_copy = 1;
720
            } else
721
                choose_sample_fmt(st, codec);
722
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
723
            if (video_stream_copy) {
724
                st->stream_copy = 1;
725
            } else
726
                choose_pixel_fmt(st, codec);
727
        }
728

    
729
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
730
            nopts = 1;
731

    
732
        new_output_stream(s, nb_output_files);
733
    }
734

    
735
    if (!nopts)
736
        s->timestamp = av_gettime();
737

    
738
    av_close_input_file(ic);
739
    return 0;
740
}
741

    
742
static double
743
get_sync_ipts(const AVOutputStream *ost)
744
{
745
    const AVInputStream *ist = ost->sync_ist;
746
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
747
}
748

    
749
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
750
    int ret;
751

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

    
771
        bsfc= bsfc->next;
772
    }
773

    
774
    ret= av_interleaved_write_frame(s, pkt);
775
    if(ret < 0){
776
        print_error("av_interleaved_write_frame()", ret);
777
        ffmpeg_exit(1);
778
    }
779
}
780

    
781
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
782

    
783
static void do_audio_out(AVFormatContext *s,
784
                         AVOutputStream *ost,
785
                         AVInputStream *ist,
786
                         unsigned char *buf, int size)
787
{
788
    uint8_t *buftmp;
789
    int64_t audio_out_size, audio_buf_size;
790
    int64_t allocated_for_size= size;
791

    
792
    int size_out, frame_bytes, ret, resample_changed;
793
    AVCodecContext *enc= ost->st->codec;
794
    AVCodecContext *dec= ist->st->codec;
795
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
796
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
797
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
798

    
799
need_realloc:
800
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
801
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
802
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
803
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
804
    audio_buf_size*= osize*enc->channels;
805

    
806
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
807
    if(coded_bps > 8*osize)
808
        audio_out_size= audio_out_size * coded_bps / (8*osize);
809
    audio_out_size += FF_MIN_BUFFER_SIZE;
810

    
811
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
812
        fprintf(stderr, "Buffer sizes too large\n");
813
        ffmpeg_exit(1);
814
    }
815

    
816
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
817
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
818
    if (!audio_buf || !audio_out){
819
        fprintf(stderr, "Out of memory in do_audio_out\n");
820
        ffmpeg_exit(1);
821
    }
822

    
823
    if (enc->channels != dec->channels)
824
        ost->audio_resample = 1;
825

    
826
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
827
                       ost->resample_channels    != dec->channels   ||
828
                       ost->resample_sample_rate != dec->sample_rate;
829

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

    
865
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
866
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
867
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
868
        if (ost->reformat_ctx)
869
            av_audio_convert_free(ost->reformat_ctx);
870
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
871
                                                   dec->sample_fmt, 1, NULL, 0);
872
        if (!ost->reformat_ctx) {
873
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
874
                av_get_sample_fmt_name(dec->sample_fmt),
875
                av_get_sample_fmt_name(enc->sample_fmt));
876
            ffmpeg_exit(1);
877
        }
878
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
879
    }
880

    
881
    if(audio_sync_method){
882
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
883
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
884
        double idelta= delta*dec->sample_rate / enc->sample_rate;
885
        int byte_delta= ((int)idelta)*2*dec->channels;
886

    
887
        //FIXME resample delay
888
        if(fabs(delta) > 50){
889
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
890
                if(byte_delta < 0){
891
                    byte_delta= FFMAX(byte_delta, -size);
892
                    size += byte_delta;
893
                    buf  -= byte_delta;
894
                    if(verbose > 2)
895
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
896
                    if(!size)
897
                        return;
898
                    ist->is_start=0;
899
                }else{
900
                    static uint8_t *input_tmp= NULL;
901
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
902

    
903
                    if(byte_delta > allocated_for_size - size){
904
                        allocated_for_size= byte_delta + (int64_t)size;
905
                        goto need_realloc;
906
                    }
907
                    ist->is_start=0;
908

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

    
929
    if (ost->audio_resample) {
930
        buftmp = audio_buf;
931
        size_out = audio_resample(ost->resample,
932
                                  (short *)buftmp, (short *)buf,
933
                                  size / (dec->channels * isize));
934
        size_out = size_out * enc->channels * osize;
935
    } else {
936
        buftmp = buf;
937
        size_out = size;
938
    }
939

    
940
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
941
        const void *ibuf[6]= {buftmp};
942
        void *obuf[6]= {audio_buf};
943
        int istride[6]= {isize};
944
        int ostride[6]= {osize};
945
        int len= size_out/istride[0];
946
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
947
            printf("av_audio_convert() failed\n");
948
            if (exit_on_error)
949
                ffmpeg_exit(1);
950
            return;
951
        }
952
        buftmp = audio_buf;
953
        size_out = len*osize;
954
    }
955

    
956
    /* now encode as many frames as possible */
957
    if (enc->frame_size > 1) {
958
        /* output resampled raw samples */
959
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
960
            fprintf(stderr, "av_fifo_realloc2() failed\n");
961
            ffmpeg_exit(1);
962
        }
963
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
964

    
965
        frame_bytes = enc->frame_size * osize * enc->channels;
966

    
967
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
968
            AVPacket pkt;
969
            av_init_packet(&pkt);
970

    
971
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
972

    
973
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
974

    
975
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
976
                                       (short *)audio_buf);
977
            if (ret < 0) {
978
                fprintf(stderr, "Audio encoding failed\n");
979
                ffmpeg_exit(1);
980
            }
981
            audio_size += ret;
982
            pkt.stream_index= ost->index;
983
            pkt.data= audio_out;
984
            pkt.size= ret;
985
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
986
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
987
            pkt.flags |= AV_PKT_FLAG_KEY;
988
            write_frame(s, &pkt, enc, ost->bitstream_filters);
989

    
990
            ost->sync_opts += enc->frame_size;
991
        }
992
    } else {
993
        AVPacket pkt;
994
        av_init_packet(&pkt);
995

    
996
        ost->sync_opts += size_out / (osize * enc->channels);
997

    
998
        /* output a pcm frame */
999
        /* determine the size of the coded buffer */
1000
        size_out /= osize;
1001
        if (coded_bps)
1002
            size_out = size_out*coded_bps/8;
1003

    
1004
        if(size_out > audio_out_size){
1005
            fprintf(stderr, "Internal error, buffer size too small\n");
1006
            ffmpeg_exit(1);
1007
        }
1008

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

    
1027
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1028
{
1029
    AVCodecContext *dec;
1030
    AVPicture *picture2;
1031
    AVPicture picture_tmp;
1032
    uint8_t *buf = 0;
1033

    
1034
    dec = ist->st->codec;
1035

    
1036
    /* deinterlace : must be done before any resize */
1037
    if (do_deinterlace) {
1038
        int size;
1039

    
1040
        /* create temporary picture */
1041
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1042
        buf = av_malloc(size);
1043
        if (!buf)
1044
            return;
1045

    
1046
        picture2 = &picture_tmp;
1047
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1048

    
1049
        if(avpicture_deinterlace(picture2, picture,
1050
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1051
            /* if error, do not deinterlace */
1052
            fprintf(stderr, "Deinterlacing failed\n");
1053
            av_free(buf);
1054
            buf = NULL;
1055
            picture2 = picture;
1056
        }
1057
    } else {
1058
        picture2 = picture;
1059
    }
1060

    
1061
    if (picture != picture2)
1062
        *picture = *picture2;
1063
    *bufp = buf;
1064
}
1065

    
1066
/* we begin to correct av delay at this threshold */
1067
#define AV_DELAY_MAX 0.100
1068

    
1069
static void do_subtitle_out(AVFormatContext *s,
1070
                            AVOutputStream *ost,
1071
                            AVInputStream *ist,
1072
                            AVSubtitle *sub,
1073
                            int64_t pts)
1074
{
1075
    static uint8_t *subtitle_out = NULL;
1076
    int subtitle_out_max_size = 1024 * 1024;
1077
    int subtitle_out_size, nb, i;
1078
    AVCodecContext *enc;
1079
    AVPacket pkt;
1080

    
1081
    if (pts == AV_NOPTS_VALUE) {
1082
        fprintf(stderr, "Subtitle packets must have a pts\n");
1083
        if (exit_on_error)
1084
            ffmpeg_exit(1);
1085
        return;
1086
    }
1087

    
1088
    enc = ost->st->codec;
1089

    
1090
    if (!subtitle_out) {
1091
        subtitle_out = av_malloc(subtitle_out_max_size);
1092
    }
1093

    
1094
    /* Note: DVB subtitle need one packet to draw them and one other
1095
       packet to clear them */
1096
    /* XXX: signal it in the codec context ? */
1097
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1098
        nb = 2;
1099
    else
1100
        nb = 1;
1101

    
1102
    for(i = 0; i < nb; i++) {
1103
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1104
        // start_display_time is required to be 0
1105
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1106
        sub->end_display_time -= sub->start_display_time;
1107
        sub->start_display_time = 0;
1108
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1109
                                                    subtitle_out_max_size, sub);
1110
        if (subtitle_out_size < 0) {
1111
            fprintf(stderr, "Subtitle encoding failed\n");
1112
            ffmpeg_exit(1);
1113
        }
1114

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

    
1132
static int bit_buffer_size= 1024*256;
1133
static uint8_t *bit_buffer= NULL;
1134

    
1135
static void do_video_out(AVFormatContext *s,
1136
                         AVOutputStream *ost,
1137
                         AVInputStream *ist,
1138
                         AVFrame *in_picture,
1139
                         int *frame_size)
1140
{
1141
    int nb_frames, i, ret;
1142
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1143
    AVCodecContext *enc, *dec;
1144
    double sync_ipts;
1145

    
1146
    enc = ost->st->codec;
1147
    dec = ist->st->codec;
1148

    
1149
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1150

    
1151
    /* by default, we output a single frame */
1152
    nb_frames = 1;
1153

    
1154
    *frame_size = 0;
1155

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

    
1181
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1182
    if (nb_frames <= 0)
1183
        return;
1184

    
1185
    formatted_picture = in_picture;
1186
    final_picture = formatted_picture;
1187
    padding_src = formatted_picture;
1188
    resampling_dst = &ost->pict_tmp;
1189

    
1190
    if (   ost->resample_height != ist->st->codec->height
1191
        || ost->resample_width  != ist->st->codec->width
1192
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1193

    
1194
        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));
1195
        if(!ost->video_resample)
1196
            ffmpeg_exit(1);
1197
    }
1198

    
1199
#if !CONFIG_AVFILTER
1200
    if (ost->video_resample) {
1201
        padding_src = NULL;
1202
        final_picture = &ost->pict_tmp;
1203
        if(  ost->resample_height != ist->st->codec->height
1204
          || ost->resample_width  != ist->st->codec->width
1205
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1206

    
1207
            /* initialize a new scaler context */
1208
            sws_freeContext(ost->img_resample_ctx);
1209
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1210
            ost->img_resample_ctx = sws_getContext(
1211
                ist->st->codec->width,
1212
                ist->st->codec->height,
1213
                ist->st->codec->pix_fmt,
1214
                ost->st->codec->width,
1215
                ost->st->codec->height,
1216
                ost->st->codec->pix_fmt,
1217
                sws_flags, NULL, NULL, NULL);
1218
            if (ost->img_resample_ctx == NULL) {
1219
                fprintf(stderr, "Cannot get resampling context\n");
1220
                ffmpeg_exit(1);
1221
            }
1222
        }
1223
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1224
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1225
    }
1226
#endif
1227

    
1228
    /* duplicates frame if needed */
1229
    for(i=0;i<nb_frames;i++) {
1230
        AVPacket pkt;
1231
        av_init_packet(&pkt);
1232
        pkt.stream_index= ost->index;
1233

    
1234
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1235
            /* raw pictures are written as AVPicture structure to
1236
               avoid any copies. We support temorarily the older
1237
               method. */
1238
            AVFrame* old_frame = enc->coded_frame;
1239
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1240
            pkt.data= (uint8_t *)final_picture;
1241
            pkt.size=  sizeof(AVPicture);
1242
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1243
            pkt.flags |= AV_PKT_FLAG_KEY;
1244

    
1245
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1246
            enc->coded_frame = old_frame;
1247
        } else {
1248
            AVFrame big_picture;
1249

    
1250
            big_picture= *final_picture;
1251
            /* better than nothing: use input picture interlaced
1252
               settings */
1253
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1254
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1255
                if(top_field_first == -1)
1256
                    big_picture.top_field_first = in_picture->top_field_first;
1257
                else
1258
                    big_picture.top_field_first = top_field_first;
1259
            }
1260

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

    
1283
            if(ret>0){
1284
                pkt.data= bit_buffer;
1285
                pkt.size= ret;
1286
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1287
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1288
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1289
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1290
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1291

    
1292
                if(enc->coded_frame->key_frame)
1293
                    pkt.flags |= AV_PKT_FLAG_KEY;
1294
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1295
                *frame_size = ret;
1296
                video_size += ret;
1297
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1298
                //        enc->frame_number-1, ret, enc->pict_type);
1299
                /* if two pass, output log */
1300
                if (ost->logfile && enc->stats_out) {
1301
                    fprintf(ost->logfile, "%s", enc->stats_out);
1302
                }
1303
            }
1304
        }
1305
        ost->sync_opts++;
1306
        ost->frame_number++;
1307
    }
1308
}
1309

    
1310
static double psnr(double d){
1311
    return -10.0*log(d)/log(10.0);
1312
}
1313

    
1314
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1315
                           int frame_size)
1316
{
1317
    AVCodecContext *enc;
1318
    int frame_number;
1319
    double ti1, bitrate, avg_bitrate;
1320

    
1321
    /* this is executed just the first time do_video_stats is called */
1322
    if (!vstats_file) {
1323
        vstats_file = fopen(vstats_filename, "w");
1324
        if (!vstats_file) {
1325
            perror("fopen");
1326
            ffmpeg_exit(1);
1327
        }
1328
    }
1329

    
1330
    enc = ost->st->codec;
1331
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1332
        frame_number = ost->frame_number;
1333
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1334
        if (enc->flags&CODEC_FLAG_PSNR)
1335
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1336

    
1337
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1338
        /* compute pts value */
1339
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1340
        if (ti1 < 0.01)
1341
            ti1 = 0.01;
1342

    
1343
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1344
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1345
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1346
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1347
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1348
    }
1349
}
1350

    
1351
static void print_report(AVFormatContext **output_files,
1352
                         AVOutputStream **ost_table, int nb_ostreams,
1353
                         int is_last_report)
1354
{
1355
    char buf[1024];
1356
    AVOutputStream *ost;
1357
    AVFormatContext *oc;
1358
    int64_t total_size;
1359
    AVCodecContext *enc;
1360
    int frame_number, vid, i;
1361
    double bitrate, ti1, pts;
1362
    static int64_t last_time = -1;
1363
    static int qp_histogram[52];
1364

    
1365
    if (!is_last_report) {
1366
        int64_t cur_time;
1367
        /* display the report every 0.5 seconds */
1368
        cur_time = av_gettime();
1369
        if (last_time == -1) {
1370
            last_time = cur_time;
1371
            return;
1372
        }
1373
        if ((cur_time - last_time) < 500000)
1374
            return;
1375
        last_time = cur_time;
1376
    }
1377

    
1378

    
1379
    oc = output_files[0];
1380

    
1381
    total_size = avio_size(oc->pb);
1382
    if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1383
        total_size= avio_tell(oc->pb);
1384

    
1385
    buf[0] = '\0';
1386
    ti1 = 1e10;
1387
    vid = 0;
1388
    for(i=0;i<nb_ostreams;i++) {
1389
        float q= -1;
1390
        ost = ost_table[i];
1391
        enc = ost->st->codec;
1392
        if(!ost->st->stream_copy && enc->coded_frame)
1393
            q= enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1394
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1395
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1396
        }
1397
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1398
            float t = (av_gettime()-timer_start) / 1000000.0;
1399

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

    
1444
    if (verbose || is_last_report) {
1445
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1446

    
1447
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1448
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1449
            (double)total_size / 1024, ti1, bitrate);
1450

    
1451
        if (nb_frames_dup || nb_frames_drop)
1452
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1453
                  nb_frames_dup, nb_frames_drop);
1454

    
1455
        if (verbose >= 0)
1456
            fprintf(stderr, "%s    \r", buf);
1457

    
1458
        fflush(stderr);
1459
    }
1460

    
1461
    if (is_last_report && verbose >= 0){
1462
        int64_t raw= audio_size + video_size + extra_size;
1463
        fprintf(stderr, "\n");
1464
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1465
                video_size/1024.0,
1466
                audio_size/1024.0,
1467
                extra_size/1024.0,
1468
                100.0*(total_size - raw)/raw
1469
        );
1470
    }
1471
}
1472

    
1473
static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1474
{
1475
    int fill_char = 0x00;
1476
    if (sample_fmt == AV_SAMPLE_FMT_U8)
1477
        fill_char = 0x80;
1478
    memset(buf, fill_char, size);
1479
}
1480

    
1481
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1482
static int output_packet(AVInputStream *ist, int ist_index,
1483
                         AVOutputStream **ost_table, int nb_ostreams,
1484
                         const AVPacket *pkt)
1485
{
1486
    AVFormatContext *os;
1487
    AVOutputStream *ost;
1488
    int ret, i;
1489
    int got_picture;
1490
    AVFrame picture;
1491
    void *buffer_to_free;
1492
    static unsigned int samples_size= 0;
1493
    AVSubtitle subtitle, *subtitle_to_free;
1494
    int64_t pkt_pts = AV_NOPTS_VALUE;
1495
#if CONFIG_AVFILTER
1496
    int frame_available;
1497
#endif
1498

    
1499
    AVPacket avpkt;
1500
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1501

    
1502
    if(ist->next_pts == AV_NOPTS_VALUE)
1503
        ist->next_pts= ist->pts;
1504

    
1505
    if (pkt == NULL) {
1506
        /* EOF handling */
1507
        av_init_packet(&avpkt);
1508
        avpkt.data = NULL;
1509
        avpkt.size = 0;
1510
        goto handle_eof;
1511
    } else {
1512
        avpkt = *pkt;
1513
    }
1514

    
1515
    if(pkt->dts != AV_NOPTS_VALUE)
1516
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1517
    if(pkt->pts != AV_NOPTS_VALUE)
1518
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1519

    
1520
    //while we have more to decode or while the decoder did output something on EOF
1521
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1522
        uint8_t *data_buf, *decoded_data_buf;
1523
        int data_size, decoded_data_size;
1524
    handle_eof:
1525
        ist->pts= ist->next_pts;
1526

    
1527
        if(avpkt.size && avpkt.size != pkt->size &&
1528
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1529
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1530
            ist->showed_multi_packet_warning=1;
1531
        }
1532

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

    
1575
                    ret = avcodec_decode_video2(ist->st->codec,
1576
                                                &picture, &got_picture, &avpkt);
1577
                    ist->st->quality= picture.quality;
1578
                    if (ret < 0)
1579
                        goto fail_decode;
1580
                    if (!got_picture) {
1581
                        /* no picture yet */
1582
                        goto discard_packet;
1583
                    }
1584
                    ist->next_pts = ist->pts = picture.best_effort_timestamp;
1585
                    if (ist->st->codec->time_base.num != 0) {
1586
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1587
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1588
                                          ist->st->codec->time_base.num * ticks) /
1589
                            ist->st->codec->time_base.den;
1590
                    }
1591
                    avpkt.size = 0;
1592
                    break;
1593
            case AVMEDIA_TYPE_SUBTITLE:
1594
                ret = avcodec_decode_subtitle2(ist->st->codec,
1595
                                               &subtitle, &got_picture, &avpkt);
1596
                if (ret < 0)
1597
                    goto fail_decode;
1598
                if (!got_picture) {
1599
                    goto discard_packet;
1600
                }
1601
                subtitle_to_free = &subtitle;
1602
                avpkt.size = 0;
1603
                break;
1604
            default:
1605
                goto fail_decode;
1606
            }
1607
        } else {
1608
            switch(ist->st->codec->codec_type) {
1609
            case AVMEDIA_TYPE_AUDIO:
1610
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1611
                    ist->st->codec->sample_rate;
1612
                break;
1613
            case AVMEDIA_TYPE_VIDEO:
1614
                if (ist->st->codec->time_base.num != 0) {
1615
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1616
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1617
                                      ist->st->codec->time_base.num * ticks) /
1618
                        ist->st->codec->time_base.den;
1619
                }
1620
                break;
1621
            }
1622
            ret = avpkt.size;
1623
            avpkt.size = 0;
1624
        }
1625

    
1626
        buffer_to_free = NULL;
1627
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1628
            pre_process_video_frame(ist, (AVPicture *)&picture,
1629
                                    &buffer_to_free);
1630
        }
1631

    
1632
#if CONFIG_AVFILTER
1633
        if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
1634
            for(i=0;i<nb_ostreams;i++) {
1635
                ost = ost_table[i];
1636
                if (ost->input_video_filter && ost->source_index == ist_index) {
1637
                    AVRational sar;
1638
                    if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1639
                    else                                  sar = ist->st->codec->sample_aspect_ratio;
1640
                    // add it to be filtered
1641
                    av_vsrc_buffer_add_frame2(ost->input_video_filter, &picture,
1642
                                             ist->pts,
1643
                                             sar, ist->st->codec->width, ist->st->codec->height,
1644
                                             ist->st->codec->pix_fmt, "0:0"); //TODO user setable params
1645
                }
1646
            }
1647
        }
1648
#endif
1649

    
1650
        // preprocess audio (volume)
1651
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1652
            if (audio_volume != 256) {
1653
                short *volp;
1654
                volp = samples;
1655
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1656
                    int v = ((*volp) * audio_volume + 128) >> 8;
1657
                    if (v < -32768) v = -32768;
1658
                    if (v >  32767) v = 32767;
1659
                    *volp++ = v;
1660
                }
1661
            }
1662
        }
1663

    
1664
        /* frame rate emulation */
1665
        if (rate_emu) {
1666
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1667
            int64_t now = av_gettime() - ist->start;
1668
            if (pts > now)
1669
                usleep(pts - now);
1670
        }
1671
        /* if output time reached then transcode raw format,
1672
           encode packets and output them */
1673
        if (start_time == 0 || ist->pts >= start_time)
1674
            for(i=0;i<nb_ostreams;i++) {
1675
                int frame_size;
1676

    
1677
                ost = ost_table[i];
1678
                if (ost->source_index == ist_index) {
1679
#if CONFIG_AVFILTER
1680
                frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1681
                    !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1682
                while (frame_available) {
1683
                    AVRational ist_pts_tb;
1684
                    if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1685
                        get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1686
                    if (ost->picref)
1687
                        ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1688
#endif
1689
                    os = output_files[ost->file_index];
1690

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

    
1694
                    if (ost->encoding_needed) {
1695
                        av_assert0(ist->decoding_needed);
1696
                        switch(ost->st->codec->codec_type) {
1697
                        case AVMEDIA_TYPE_AUDIO:
1698
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1699
                            break;
1700
                        case AVMEDIA_TYPE_VIDEO:
1701
#if CONFIG_AVFILTER
1702
                            if (ost->picref->video && !ost->frame_aspect_ratio)
1703
                                ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1704
#endif
1705
                            do_video_out(os, ost, ist, &picture, &frame_size);
1706
                            if (vstats_filename && frame_size)
1707
                                do_video_stats(os, ost, frame_size);
1708
                            break;
1709
                        case AVMEDIA_TYPE_SUBTITLE:
1710
                            do_subtitle_out(os, ost, ist, &subtitle,
1711
                                            pkt->pts);
1712
                            break;
1713
                        default:
1714
                            abort();
1715
                        }
1716
                    } else {
1717
                        AVFrame avframe; //FIXME/XXX remove this
1718
                        AVPacket opkt;
1719
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1720

    
1721
                        av_init_packet(&opkt);
1722

    
1723
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1724
#if !CONFIG_AVFILTER
1725
                            continue;
1726
#else
1727
                            goto cont;
1728
#endif
1729

    
1730
                        /* no reencoding needed : output the packet directly */
1731
                        /* force the input stream PTS */
1732

    
1733
                        avcodec_get_frame_defaults(&avframe);
1734
                        ost->st->codec->coded_frame= &avframe;
1735
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1736

    
1737
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1738
                            audio_size += data_size;
1739
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1740
                            video_size += data_size;
1741
                            ost->sync_opts++;
1742
                        }
1743

    
1744
                        opkt.stream_index= ost->index;
1745
                        if(pkt->pts != AV_NOPTS_VALUE)
1746
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1747
                        else
1748
                            opkt.pts= AV_NOPTS_VALUE;
1749

    
1750
                        if (pkt->dts == AV_NOPTS_VALUE)
1751
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1752
                        else
1753
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1754
                        opkt.dts -= ost_tb_start_time;
1755

    
1756
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1757
                        opkt.flags= pkt->flags;
1758

    
1759
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1760
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1761
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1762
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1763
                           ) {
1764
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1765
                                opkt.destruct= av_destruct_packet;
1766
                        } else {
1767
                            opkt.data = data_buf;
1768
                            opkt.size = data_size;
1769
                        }
1770

    
1771
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1772
                        ost->st->codec->frame_number++;
1773
                        ost->frame_number++;
1774
                        av_free_packet(&opkt);
1775
                    }
1776
#if CONFIG_AVFILTER
1777
                    cont:
1778
                    frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1779
                                       ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1780
                    if(ost->picref)
1781
                        avfilter_unref_buffer(ost->picref);
1782
                }
1783
#endif
1784
                }
1785
            }
1786

    
1787
        av_free(buffer_to_free);
1788
        /* XXX: allocate the subtitles in the codec ? */
1789
        if (subtitle_to_free) {
1790
            avsubtitle_free(subtitle_to_free);
1791
            subtitle_to_free = NULL;
1792
        }
1793
    }
1794
 discard_packet:
1795
    if (pkt == NULL) {
1796
        /* EOF handling */
1797

    
1798
        for(i=0;i<nb_ostreams;i++) {
1799
            ost = ost_table[i];
1800
            if (ost->source_index == ist_index) {
1801
                AVCodecContext *enc= ost->st->codec;
1802
                os = output_files[ost->file_index];
1803

    
1804
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1805
                    continue;
1806
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1807
                    continue;
1808

    
1809
                if (ost->encoding_needed) {
1810
                    for(;;) {
1811
                        AVPacket pkt;
1812
                        int fifo_bytes;
1813
                        av_init_packet(&pkt);
1814
                        pkt.stream_index= ost->index;
1815

    
1816
                        switch(ost->st->codec->codec_type) {
1817
                        case AVMEDIA_TYPE_AUDIO:
1818
                            fifo_bytes = av_fifo_size(ost->fifo);
1819
                            ret = 0;
1820
                            /* encode any samples remaining in fifo */
1821
                            if (fifo_bytes > 0) {
1822
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1823
                                int fs_tmp = enc->frame_size;
1824

    
1825
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1826
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1827
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1828
                                } else { /* pad */
1829
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1830
                                    if (allocated_audio_buf_size < frame_bytes)
1831
                                        ffmpeg_exit(1);
1832
                                    generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1833
                                }
1834

    
1835
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1836
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1837
                                                          ost->st->time_base.num, enc->sample_rate);
1838
                                enc->frame_size = fs_tmp;
1839
                            }
1840
                            if(ret <= 0) {
1841
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1842
                            }
1843
                            if (ret < 0) {
1844
                                fprintf(stderr, "Audio encoding failed\n");
1845
                                ffmpeg_exit(1);
1846
                            }
1847
                            audio_size += ret;
1848
                            pkt.flags |= AV_PKT_FLAG_KEY;
1849
                            break;
1850
                        case AVMEDIA_TYPE_VIDEO:
1851
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1852
                            if (ret < 0) {
1853
                                fprintf(stderr, "Video encoding failed\n");
1854
                                ffmpeg_exit(1);
1855
                            }
1856
                            video_size += ret;
1857
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1858
                                pkt.flags |= AV_PKT_FLAG_KEY;
1859
                            if (ost->logfile && enc->stats_out) {
1860
                                fprintf(ost->logfile, "%s", enc->stats_out);
1861
                            }
1862
                            break;
1863
                        default:
1864
                            ret=-1;
1865
                        }
1866

    
1867
                        if(ret<=0)
1868
                            break;
1869
                        pkt.data= bit_buffer;
1870
                        pkt.size= ret;
1871
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1872
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1873
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1874
                    }
1875
                }
1876
            }
1877
        }
1878
    }
1879

    
1880
    return 0;
1881
 fail_decode:
1882
    return -1;
1883
}
1884

    
1885
static void print_sdp(AVFormatContext **avc, int n)
1886
{
1887
    char sdp[2048];
1888

    
1889
    av_sdp_create(avc, n, sdp, sizeof(sdp));
1890
    printf("SDP:\n%s\n", sdp);
1891
    fflush(stdout);
1892
}
1893

    
1894
static int copy_chapters(int infile, int outfile)
1895
{
1896
    AVFormatContext *is = input_files[infile];
1897
    AVFormatContext *os = output_files[outfile];
1898
    int i;
1899

    
1900
    for (i = 0; i < is->nb_chapters; i++) {
1901
        AVChapter *in_ch = is->chapters[i], *out_ch;
1902
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1903
                                      AV_TIME_BASE_Q, in_ch->time_base);
1904
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1905
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1906

    
1907

    
1908
        if (in_ch->end < ts_off)
1909
            continue;
1910
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1911
            break;
1912

    
1913
        out_ch = av_mallocz(sizeof(AVChapter));
1914
        if (!out_ch)
1915
            return AVERROR(ENOMEM);
1916

    
1917
        out_ch->id        = in_ch->id;
1918
        out_ch->time_base = in_ch->time_base;
1919
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1920
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1921

    
1922
        if (metadata_chapters_autocopy)
1923
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1924

    
1925
        os->nb_chapters++;
1926
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1927
        if (!os->chapters)
1928
            return AVERROR(ENOMEM);
1929
        os->chapters[os->nb_chapters - 1] = out_ch;
1930
    }
1931
    return 0;
1932
}
1933

    
1934
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1935
                                    AVCodecContext *avctx)
1936
{
1937
    char *p;
1938
    int n = 1, i;
1939
    int64_t t;
1940

    
1941
    for (p = kf; *p; p++)
1942
        if (*p == ',')
1943
            n++;
1944
    ost->forced_kf_count = n;
1945
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1946
    if (!ost->forced_kf_pts) {
1947
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1948
        ffmpeg_exit(1);
1949
    }
1950
    for (i = 0; i < n; i++) {
1951
        p = i ? strchr(p, ',') + 1 : kf;
1952
        t = parse_time_or_die("force_key_frames", p, 1);
1953
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1954
    }
1955
}
1956

    
1957
/*
1958
 * The following code is the main loop of the file converter
1959
 */
1960
static int transcode(AVFormatContext **output_files,
1961
                     int nb_output_files,
1962
                     AVFormatContext **input_files,
1963
                     int nb_input_files,
1964
                     AVStreamMap *stream_maps, int nb_stream_maps)
1965
{
1966
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0, step;
1967
    AVFormatContext *is, *os;
1968
    AVCodecContext *codec, *icodec;
1969
    AVOutputStream *ost, **ost_table = NULL;
1970
    AVInputStream *ist, **ist_table = NULL;
1971
    AVInputFile *file_table;
1972
    char error[1024];
1973
    int key;
1974
    int want_sdp = 1;
1975
    uint8_t no_packet[MAX_FILES]={0};
1976
    int no_packet_count=0;
1977
    int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
1978
    int nb_streams[AVMEDIA_TYPE_NB]={0};
1979

    
1980
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1981
    if (!file_table)
1982
        goto fail;
1983

    
1984
    /* input stream init */
1985
    j = 0;
1986
    for(i=0;i<nb_input_files;i++) {
1987
        is = input_files[i];
1988
        file_table[i].ist_index = j;
1989
        file_table[i].nb_streams = is->nb_streams;
1990
        j += is->nb_streams;
1991
    }
1992
    nb_istreams = j;
1993

    
1994
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1995
    if (!ist_table)
1996
        goto fail;
1997

    
1998
    for(i=0;i<nb_istreams;i++) {
1999
        ist = av_mallocz(sizeof(AVInputStream));
2000
        if (!ist)
2001
            goto fail;
2002
        ist_table[i] = ist;
2003
    }
2004
    j = 0;
2005
    for(i=0;i<nb_input_files;i++) {
2006
        is = input_files[i];
2007
        for(k=0;k<is->nb_streams;k++) {
2008
            ist = ist_table[j++];
2009
            ist->st = is->streams[k];
2010
            ist->file_index = i;
2011
            ist->index = k;
2012
            ist->discard = 1; /* the stream is discarded by default
2013
                                 (changed later) */
2014

    
2015
            if (rate_emu) {
2016
                ist->start = av_gettime();
2017
            }
2018
        }
2019
    }
2020

    
2021
    /* output stream init */
2022
    nb_ostreams = 0;
2023
    for(i=0;i<nb_output_files;i++) {
2024
        os = output_files[i];
2025
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2026
            av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2027
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2028
            ret = AVERROR(EINVAL);
2029
            goto fail;
2030
        }
2031
        nb_ostreams += os->nb_streams;
2032
    }
2033
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2034
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
2035
        ret = AVERROR(EINVAL);
2036
        goto fail;
2037
    }
2038

    
2039
    /* Sanity check the mapping args -- do the input files & streams exist? */
2040
    for(i=0;i<nb_stream_maps;i++) {
2041
        int fi = stream_maps[i].file_index;
2042
        int si = stream_maps[i].stream_index;
2043

    
2044
        if (fi < 0 || fi > nb_input_files - 1 ||
2045
            si < 0 || si > file_table[fi].nb_streams - 1) {
2046
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2047
            ret = AVERROR(EINVAL);
2048
            goto fail;
2049
        }
2050
        fi = stream_maps[i].sync_file_index;
2051
        si = stream_maps[i].sync_stream_index;
2052
        if (fi < 0 || fi > nb_input_files - 1 ||
2053
            si < 0 || si > file_table[fi].nb_streams - 1) {
2054
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2055
            ret = AVERROR(EINVAL);
2056
            goto fail;
2057
        }
2058
    }
2059

    
2060
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2061
    if (!ost_table)
2062
        goto fail;
2063

    
2064
    for(k=0;k<nb_output_files;k++) {
2065
        os = output_files[k];
2066
        for(i=0;i<os->nb_streams;i++,n++) {
2067
            nb_streams[os->streams[i]->codec->codec_type]++;
2068
        }
2069
    }
2070
    for(step=1<<30; step; step>>=1){
2071
        int found_streams[AVMEDIA_TYPE_NB]={0};
2072
        for(j=0; j<AVMEDIA_TYPE_NB; j++)
2073
            nb_frame_threshold[j] += step;
2074

    
2075
        for(j=0; j<nb_istreams; j++) {
2076
            int skip=0;
2077
            ist = ist_table[j];
2078
            if(opt_programid){
2079
                int pi,si;
2080
                AVFormatContext *f= input_files[ ist->file_index ];
2081
                skip=1;
2082
                for(pi=0; pi<f->nb_programs; pi++){
2083
                    AVProgram *p= f->programs[pi];
2084
                    if(p->id == opt_programid)
2085
                        for(si=0; si<p->nb_stream_indexes; si++){
2086
                            if(f->streams[ p->stream_index[si] ] == ist->st)
2087
                                skip=0;
2088
                        }
2089
                }
2090
            }
2091
            if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
2092
                && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2093
                found_streams[ist->st->codec->codec_type]++;
2094
            }
2095
        }
2096
        for(j=0; j<AVMEDIA_TYPE_NB; j++)
2097
            if(found_streams[j] < nb_streams[j])
2098
                nb_frame_threshold[j] -= step;
2099
    }
2100
    n = 0;
2101
    for(k=0;k<nb_output_files;k++) {
2102
        os = output_files[k];
2103
        for(i=0;i<os->nb_streams;i++,n++) {
2104
            int found;
2105
            ost = ost_table[n] = output_streams_for_file[k][i];
2106
            ost->st = os->streams[i];
2107
            if (nb_stream_maps > 0) {
2108
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2109
                    stream_maps[n].stream_index;
2110

    
2111
                /* Sanity check that the stream types match */
2112
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2113
                    int i= ost->file_index;
2114
                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2115
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2116
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2117
                        ost->file_index, ost->index);
2118
                    ffmpeg_exit(1);
2119
                }
2120

    
2121
            } else {
2122
                /* get corresponding input stream index : we select the first one with the right type */
2123
                found = 0;
2124
                for(j=0;j<nb_istreams;j++) {
2125
                    int skip=0;
2126
                    ist = ist_table[j];
2127
                    if(opt_programid){
2128
                        int pi,si;
2129
                        AVFormatContext *f= input_files[ ist->file_index ];
2130
                        skip=1;
2131
                        for(pi=0; pi<f->nb_programs; pi++){
2132
                            AVProgram *p= f->programs[pi];
2133
                            if(p->id == opt_programid)
2134
                                for(si=0; si<p->nb_stream_indexes; si++){
2135
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2136
                                        skip=0;
2137
                                }
2138
                        }
2139
                    }
2140
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2141
                        ist->st->codec->codec_type == ost->st->codec->codec_type &&
2142
                        nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2143
                            ost->source_index = j;
2144
                            found = 1;
2145
                            break;
2146
                    }
2147
                }
2148

    
2149
                if (!found) {
2150
                    if(! opt_programid) {
2151
                        /* try again and reuse existing stream */
2152
                        for(j=0;j<nb_istreams;j++) {
2153
                            ist = ist_table[j];
2154
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2155
                                && ist->st->discard != AVDISCARD_ALL) {
2156
                                ost->source_index = j;
2157
                                found = 1;
2158
                            }
2159
                        }
2160
                    }
2161
                    if (!found) {
2162
                        int i= ost->file_index;
2163
                        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2164
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2165
                                ost->file_index, ost->index);
2166
                        ffmpeg_exit(1);
2167
                    }
2168
                }
2169
            }
2170
            ist = ist_table[ost->source_index];
2171
            ist->discard = 0;
2172
            ost->sync_ist = (nb_stream_maps > 0) ?
2173
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2174
                         stream_maps[n].sync_stream_index] : ist;
2175
        }
2176
    }
2177

    
2178
    /* for each output stream, we compute the right encoding parameters */
2179
    for(i=0;i<nb_ostreams;i++) {
2180
        ost = ost_table[i];
2181
        os = output_files[ost->file_index];
2182
        ist = ist_table[ost->source_index];
2183

    
2184
        codec = ost->st->codec;
2185
        icodec = ist->st->codec;
2186

    
2187
        if (metadata_streams_autocopy)
2188
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2189
                             AV_METADATA_DONT_OVERWRITE);
2190

    
2191
        ost->st->disposition = ist->st->disposition;
2192
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2193
        codec->chroma_sample_location = icodec->chroma_sample_location;
2194

    
2195
        if (ost->st->stream_copy) {
2196
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2197

    
2198
            if (extra_size > INT_MAX)
2199
                goto fail;
2200

    
2201
            /* if stream_copy is selected, no need to decode or encode */
2202
            codec->codec_id = icodec->codec_id;
2203
            codec->codec_type = icodec->codec_type;
2204

    
2205
            if(!codec->codec_tag){
2206
                if(   !os->oformat->codec_tag
2207
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2208
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2209
                    codec->codec_tag = icodec->codec_tag;
2210
            }
2211

    
2212
            codec->bit_rate = icodec->bit_rate;
2213
            codec->rc_max_rate    = icodec->rc_max_rate;
2214
            codec->rc_buffer_size = icodec->rc_buffer_size;
2215
            codec->extradata= av_mallocz(extra_size);
2216
            if (!codec->extradata)
2217
                goto fail;
2218
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2219
            codec->extradata_size= icodec->extradata_size;
2220
            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){
2221
                codec->time_base = icodec->time_base;
2222
                codec->time_base.num *= icodec->ticks_per_frame;
2223
                av_reduce(&codec->time_base.num, &codec->time_base.den,
2224
                          codec->time_base.num, codec->time_base.den, INT_MAX);
2225
            }else
2226
                codec->time_base = ist->st->time_base;
2227
            switch(codec->codec_type) {
2228
            case AVMEDIA_TYPE_AUDIO:
2229
                if(audio_volume != 256) {
2230
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2231
                    ffmpeg_exit(1);
2232
                }
2233
                codec->channel_layout = icodec->channel_layout;
2234
                codec->sample_rate = icodec->sample_rate;
2235
                codec->channels = icodec->channels;
2236
                codec->frame_size = icodec->frame_size;
2237
                codec->audio_service_type = icodec->audio_service_type;
2238
                codec->block_align= icodec->block_align;
2239
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2240
                    codec->block_align= 0;
2241
                if(codec->codec_id == CODEC_ID_AC3)
2242
                    codec->block_align= 0;
2243
                break;
2244
            case AVMEDIA_TYPE_VIDEO:
2245
                codec->pix_fmt = icodec->pix_fmt;
2246
                codec->width = icodec->width;
2247
                codec->height = icodec->height;
2248
                codec->has_b_frames = icodec->has_b_frames;
2249
                if (!codec->sample_aspect_ratio.num) {
2250
                    codec->sample_aspect_ratio =
2251
                    ost->st->sample_aspect_ratio =
2252
                        ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2253
                        ist->st->codec->sample_aspect_ratio.num ?
2254
                        ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2255
                }
2256
                break;
2257
            case AVMEDIA_TYPE_SUBTITLE:
2258
                codec->width = icodec->width;
2259
                codec->height = icodec->height;
2260
                break;
2261
            default:
2262
                abort();
2263
            }
2264
        } else {
2265
            switch(codec->codec_type) {
2266
            case AVMEDIA_TYPE_AUDIO:
2267
                ost->fifo= av_fifo_alloc(1024);
2268
                if(!ost->fifo)
2269
                    goto fail;
2270
                ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2271
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2272
                icodec->request_channels = codec->channels;
2273
                ist->decoding_needed = 1;
2274
                ost->encoding_needed = 1;
2275
                ost->resample_sample_fmt  = icodec->sample_fmt;
2276
                ost->resample_sample_rate = icodec->sample_rate;
2277
                ost->resample_channels    = icodec->channels;
2278
                break;
2279
            case AVMEDIA_TYPE_VIDEO:
2280
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2281
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2282
                    ffmpeg_exit(1);
2283
                }
2284
                ost->video_resample = (codec->width != icodec->width   ||
2285
                                       codec->height != icodec->height ||
2286
                        (codec->pix_fmt != icodec->pix_fmt));
2287
                if (ost->video_resample) {
2288
#if !CONFIG_AVFILTER
2289
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2290
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2291
                                         codec->width, codec->height)) {
2292
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2293
                        ffmpeg_exit(1);
2294
                    }
2295
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2296
                    ost->img_resample_ctx = sws_getContext(
2297
                        icodec->width,
2298
                        icodec->height,
2299
                            icodec->pix_fmt,
2300
                            codec->width,
2301
                            codec->height,
2302
                            codec->pix_fmt,
2303
                            sws_flags, NULL, NULL, NULL);
2304
                    if (ost->img_resample_ctx == NULL) {
2305
                        fprintf(stderr, "Cannot get resampling context\n");
2306
                        ffmpeg_exit(1);
2307
                    }
2308

    
2309
                    ost->original_height = icodec->height;
2310
                    ost->original_width  = icodec->width;
2311
#endif
2312
                    codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2313
                }
2314
                ost->resample_height = icodec->height;
2315
                ost->resample_width  = icodec->width;
2316
                ost->resample_pix_fmt= icodec->pix_fmt;
2317
                ost->encoding_needed = 1;
2318
                ist->decoding_needed = 1;
2319

    
2320
#if CONFIG_AVFILTER
2321
                if (configure_video_filters(ist, ost)) {
2322
                    fprintf(stderr, "Error opening filters!\n");
2323
                    exit(1);
2324
                }
2325
#endif
2326
                break;
2327
            case AVMEDIA_TYPE_SUBTITLE:
2328
                ost->encoding_needed = 1;
2329
                ist->decoding_needed = 1;
2330
                break;
2331
            default:
2332
                abort();
2333
                break;
2334
            }
2335
            /* two pass mode */
2336
            if (ost->encoding_needed &&
2337
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2338
                char logfilename[1024];
2339
                FILE *f;
2340

    
2341
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2342
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2343
                         i);
2344
                if (codec->flags & CODEC_FLAG_PASS1) {
2345
                    f = fopen(logfilename, "wb");
2346
                    if (!f) {
2347
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2348
                        ffmpeg_exit(1);
2349
                    }
2350
                    ost->logfile = f;
2351
                } else {
2352
                    char  *logbuffer;
2353
                    size_t logbuffer_size;
2354
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2355
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2356
                        ffmpeg_exit(1);
2357
                    }
2358
                    codec->stats_in = logbuffer;
2359
                }
2360
            }
2361
        }
2362
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2363
            /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2364
            int size= codec->width * codec->height;
2365
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2366
        }
2367
    }
2368

    
2369
    if (!bit_buffer)
2370
        bit_buffer = av_malloc(bit_buffer_size);
2371
    if (!bit_buffer) {
2372
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2373
                bit_buffer_size);
2374
        ret = AVERROR(ENOMEM);
2375
        goto fail;
2376
    }
2377

    
2378
    /* open each encoder */
2379
    for(i=0;i<nb_ostreams;i++) {
2380
        ost = ost_table[i];
2381
        if (ost->encoding_needed) {
2382
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2383
            AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2384
            if (!codec)
2385
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2386
            if (!codec) {
2387
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2388
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2389
                ret = AVERROR(EINVAL);
2390
                goto dump_format;
2391
            }
2392
            if (dec->subtitle_header) {
2393
                ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2394
                if (!ost->st->codec->subtitle_header) {
2395
                    ret = AVERROR(ENOMEM);
2396
                    goto dump_format;
2397
                }
2398
                memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2399
                ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2400
            }
2401
            if (avcodec_open(ost->st->codec, codec) < 0) {
2402
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2403
                        ost->file_index, ost->index);
2404
                ret = AVERROR(EINVAL);
2405
                goto dump_format;
2406
            }
2407
            extra_size += ost->st->codec->extradata_size;
2408
        }
2409
    }
2410

    
2411
    /* open each decoder */
2412
    for(i=0;i<nb_istreams;i++) {
2413
        ist = ist_table[i];
2414
        if (ist->decoding_needed) {
2415
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2416
            if (!codec)
2417
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2418
            if (!codec) {
2419
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2420
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2421
                ret = AVERROR(EINVAL);
2422
                goto dump_format;
2423
            }
2424
            if (avcodec_open(ist->st->codec, codec) < 0) {
2425
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2426
                        ist->file_index, ist->index);
2427
                ret = AVERROR(EINVAL);
2428
                goto dump_format;
2429
            }
2430
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2431
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2432
        }
2433
    }
2434

    
2435
    /* init pts */
2436
    for(i=0;i<nb_istreams;i++) {
2437
        AVStream *st;
2438
        ist = ist_table[i];
2439
        st= ist->st;
2440
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2441
        ist->next_pts = AV_NOPTS_VALUE;
2442
        ist->is_start = 1;
2443
    }
2444

    
2445
    /* set meta data information from input file if required */
2446
    for (i=0;i<nb_meta_data_maps;i++) {
2447
        AVFormatContext *files[2];
2448
        AVMetadata      **meta[2];
2449
        int j;
2450

    
2451
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2452
        if ((index) < 0 || (index) >= (nb_elems)) {\
2453
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2454
                     (desc), (index));\
2455
            ret = AVERROR(EINVAL);\
2456
            goto dump_format;\
2457
        }
2458

    
2459
        int out_file_index = meta_data_maps[i][0].file;
2460
        int in_file_index = meta_data_maps[i][1].file;
2461
        if (in_file_index < 0 || out_file_index < 0)
2462
            continue;
2463
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2464
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2465

    
2466
        files[0] = output_files[out_file_index];
2467
        files[1] = input_files[in_file_index];
2468

    
2469
        for (j = 0; j < 2; j++) {
2470
            AVMetaDataMap *map = &meta_data_maps[i][j];
2471

    
2472
            switch (map->type) {
2473
            case 'g':
2474
                meta[j] = &files[j]->metadata;
2475
                break;
2476
            case 's':
2477
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2478
                meta[j] = &files[j]->streams[map->index]->metadata;
2479
                break;
2480
            case 'c':
2481
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2482
                meta[j] = &files[j]->chapters[map->index]->metadata;
2483
                break;
2484
            case 'p':
2485
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2486
                meta[j] = &files[j]->programs[map->index]->metadata;
2487
                break;
2488
            }
2489
        }
2490

    
2491
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2492
    }
2493

    
2494
    /* copy global metadata by default */
2495
    if (metadata_global_autocopy) {
2496

    
2497
        for (i = 0; i < nb_output_files; i++)
2498
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2499
                             AV_METADATA_DONT_OVERWRITE);
2500
    }
2501

    
2502
    /* copy chapters according to chapter maps */
2503
    for (i = 0; i < nb_chapter_maps; i++) {
2504
        int infile  = chapter_maps[i].in_file;
2505
        int outfile = chapter_maps[i].out_file;
2506

    
2507
        if (infile < 0 || outfile < 0)
2508
            continue;
2509
        if (infile >= nb_input_files) {
2510
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2511
            ret = AVERROR(EINVAL);
2512
            goto dump_format;
2513
        }
2514
        if (outfile >= nb_output_files) {
2515
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2516
            ret = AVERROR(EINVAL);
2517
            goto dump_format;
2518
        }
2519
        copy_chapters(infile, outfile);
2520
    }
2521

    
2522
    /* copy chapters from the first input file that has them*/
2523
    if (!nb_chapter_maps)
2524
        for (i = 0; i < nb_input_files; i++) {
2525
            if (!input_files[i]->nb_chapters)
2526
                continue;
2527

    
2528
            for (j = 0; j < nb_output_files; j++)
2529
                if ((ret = copy_chapters(i, j)) < 0)
2530
                    goto dump_format;
2531
            break;
2532
        }
2533

    
2534
    /* open files and write file headers */
2535
    for(i=0;i<nb_output_files;i++) {
2536
        os = output_files[i];
2537
        if (av_write_header(os) < 0) {
2538
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2539
            ret = AVERROR(EINVAL);
2540
            goto dump_format;
2541
        }
2542
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2543
            want_sdp = 0;
2544
        }
2545
    }
2546

    
2547
 dump_format:
2548
    /* dump the file output parameters - cannot be done before in case
2549
       of stream copy */
2550
    for(i=0;i<nb_output_files;i++) {
2551
        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2552
    }
2553

    
2554
    /* dump the stream mapping */
2555
    if (verbose >= 0) {
2556
        fprintf(stderr, "Stream mapping:\n");
2557
        for(i=0;i<nb_ostreams;i++) {
2558
            ost = ost_table[i];
2559
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2560
                    ist_table[ost->source_index]->file_index,
2561
                    ist_table[ost->source_index]->index,
2562
                    ost->file_index,
2563
                    ost->index);
2564
            if (ost->sync_ist != ist_table[ost->source_index])
2565
                fprintf(stderr, " [sync #%d.%d]",
2566
                        ost->sync_ist->file_index,
2567
                        ost->sync_ist->index);
2568
            fprintf(stderr, "\n");
2569
        }
2570
    }
2571

    
2572
    if (ret) {
2573
        fprintf(stderr, "%s\n", error);
2574
        goto fail;
2575
    }
2576

    
2577
    if (want_sdp) {
2578
        print_sdp(output_files, nb_output_files);
2579
    }
2580

    
2581
    if (!using_stdin) {
2582
        if(verbose >= 0)
2583
            fprintf(stderr, "Press [q] to stop encoding\n");
2584
        avio_set_interrupt_cb(decode_interrupt_cb);
2585
    }
2586
    term_init();
2587

    
2588
    timer_start = av_gettime();
2589

    
2590
    for(; received_sigterm == 0;) {
2591
        int file_index, ist_index;
2592
        AVPacket pkt;
2593
        double ipts_min;
2594
        double opts_min;
2595

    
2596
    redo:
2597
        ipts_min= 1e100;
2598
        opts_min= 1e100;
2599
        /* if 'q' pressed, exits */
2600
        if (!using_stdin) {
2601
            if (q_pressed)
2602
                break;
2603
            /* read_key() returns 0 on EOF */
2604
            key = read_key();
2605
            if (key == 'q')
2606
                break;
2607
        }
2608

    
2609
        /* select the stream that we must read now by looking at the
2610
           smallest output pts */
2611
        file_index = -1;
2612
        for(i=0;i<nb_ostreams;i++) {
2613
            double ipts, opts;
2614
            ost = ost_table[i];
2615
            os = output_files[ost->file_index];
2616
            ist = ist_table[ost->source_index];
2617
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2618
                continue;
2619
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2620
            ipts = (double)ist->pts;
2621
            if (!file_table[ist->file_index].eof_reached){
2622
                if(ipts < ipts_min) {
2623
                    ipts_min = ipts;
2624
                    if(input_sync ) file_index = ist->file_index;
2625
                }
2626
                if(opts < opts_min) {
2627
                    opts_min = opts;
2628
                    if(!input_sync) file_index = ist->file_index;
2629
                }
2630
            }
2631
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2632
                file_index= -1;
2633
                break;
2634
            }
2635
        }
2636
        /* if none, if is finished */
2637
        if (file_index < 0) {
2638
            if(no_packet_count){
2639
                no_packet_count=0;
2640
                memset(no_packet, 0, sizeof(no_packet));
2641
                usleep(10000);
2642
                continue;
2643
            }
2644
            break;
2645
        }
2646

    
2647
        /* finish if limit size exhausted */
2648
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2649
            break;
2650

    
2651
        /* read a frame from it and output it in the fifo */
2652
        is = input_files[file_index];
2653
        ret= av_read_frame(is, &pkt);
2654
        if(ret == AVERROR(EAGAIN)){
2655
            no_packet[file_index]=1;
2656
            no_packet_count++;
2657
            continue;
2658
        }
2659
        if (ret < 0) {
2660
            file_table[file_index].eof_reached = 1;
2661
            if (opt_shortest)
2662
                break;
2663
            else
2664
                continue;
2665
        }
2666

    
2667
        no_packet_count=0;
2668
        memset(no_packet, 0, sizeof(no_packet));
2669

    
2670
        if (do_pkt_dump) {
2671
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2672
                             is->streams[pkt.stream_index]);
2673
        }
2674
        /* the following test is needed in case new streams appear
2675
           dynamically in stream : we ignore them */
2676
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2677
            goto discard_packet;
2678
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2679
        ist = ist_table[ist_index];
2680
        if (ist->discard)
2681
            goto discard_packet;
2682

    
2683
        if (pkt.dts != AV_NOPTS_VALUE)
2684
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2685
        if (pkt.pts != AV_NOPTS_VALUE)
2686
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2687

    
2688
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2689
            && input_files_ts_scale[file_index][pkt.stream_index]){
2690
            if(pkt.pts != AV_NOPTS_VALUE)
2691
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2692
            if(pkt.dts != AV_NOPTS_VALUE)
2693
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2694
        }
2695

    
2696
//        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);
2697
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2698
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2699
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2700
            int64_t delta= pkt_dts - ist->next_pts;
2701
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2702
                input_files_ts_offset[ist->file_index]-= delta;
2703
                if (verbose > 2)
2704
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2705
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2706
                if(pkt.pts != AV_NOPTS_VALUE)
2707
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2708
            }
2709
        }
2710

    
2711
        /* finish if recording time exhausted */
2712
        if (recording_time != INT64_MAX &&
2713
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2714
            ist->is_past_recording_time = 1;
2715
            goto discard_packet;
2716
        }
2717

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

    
2721
            if (verbose >= 0)
2722
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2723
                        ist->file_index, ist->index);
2724
            if (exit_on_error)
2725
                ffmpeg_exit(1);
2726
            av_free_packet(&pkt);
2727
            goto redo;
2728
        }
2729

    
2730
    discard_packet:
2731
        av_free_packet(&pkt);
2732

    
2733
        /* dump report by using the output first video and audio streams */
2734
        print_report(output_files, ost_table, nb_ostreams, 0);
2735
    }
2736

    
2737
    /* at the end of stream, we must flush the decoder buffers */
2738
    for(i=0;i<nb_istreams;i++) {
2739
        ist = ist_table[i];
2740
        if (ist->decoding_needed) {
2741
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2742
        }
2743
    }
2744

    
2745
    term_exit();
2746

    
2747
    /* write the trailer if needed and close file */
2748
    for(i=0;i<nb_output_files;i++) {
2749
        os = output_files[i];
2750
        av_write_trailer(os);
2751
    }
2752

    
2753
    /* dump report by using the first video and audio streams */
2754
    print_report(output_files, ost_table, nb_ostreams, 1);
2755

    
2756
    /* close each encoder */
2757
    for(i=0;i<nb_ostreams;i++) {
2758
        ost = ost_table[i];
2759
        if (ost->encoding_needed) {
2760
            av_freep(&ost->st->codec->stats_in);
2761
            avcodec_close(ost->st->codec);
2762
        }
2763
#if CONFIG_AVFILTER
2764
        avfilter_graph_free(&ost->graph);
2765
#endif
2766
    }
2767

    
2768
    /* close each decoder */
2769
    for(i=0;i<nb_istreams;i++) {
2770
        ist = ist_table[i];
2771
        if (ist->decoding_needed) {
2772
            avcodec_close(ist->st->codec);
2773
        }
2774
    }
2775

    
2776
    /* finished ! */
2777
    ret = 0;
2778

    
2779
 fail:
2780
    av_freep(&bit_buffer);
2781
    av_free(file_table);
2782

    
2783
    if (ist_table) {
2784
        for(i=0;i<nb_istreams;i++) {
2785
            ist = ist_table[i];
2786
            av_free(ist);
2787
        }
2788
        av_free(ist_table);
2789
    }
2790
    if (ost_table) {
2791
        for(i=0;i<nb_ostreams;i++) {
2792
            ost = ost_table[i];
2793
            if (ost) {
2794
                if (ost->st->stream_copy)
2795
                    av_freep(&ost->st->codec->extradata);
2796
                if (ost->logfile) {
2797
                    fclose(ost->logfile);
2798
                    ost->logfile = NULL;
2799
                }
2800
                av_fifo_free(ost->fifo); /* works even if fifo is not
2801
                                             initialized but set to zero */
2802
                av_freep(&ost->st->codec->subtitle_header);
2803
                av_free(ost->pict_tmp.data[0]);
2804
                av_free(ost->forced_kf_pts);
2805
                if (ost->video_resample)
2806
                    sws_freeContext(ost->img_resample_ctx);
2807
                if (ost->resample)
2808
                    audio_resample_close(ost->resample);
2809
                if (ost->reformat_ctx)
2810
                    av_audio_convert_free(ost->reformat_ctx);
2811
                av_free(ost);
2812
            }
2813
        }
2814
        av_free(ost_table);
2815
    }
2816
    return ret;
2817
}
2818

    
2819
static void opt_format(const char *arg)
2820
{
2821
    last_asked_format = arg;
2822
}
2823

    
2824
static void opt_video_rc_override_string(const char *arg)
2825
{
2826
    video_rc_override_string = arg;
2827
}
2828

    
2829
static int opt_me_threshold(const char *opt, const char *arg)
2830
{
2831
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2832
    return 0;
2833
}
2834

    
2835
static int opt_verbose(const char *opt, const char *arg)
2836
{
2837
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2838
    return 0;
2839
}
2840

    
2841
static int opt_frame_rate(const char *opt, const char *arg)
2842
{
2843
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2844
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2845
        ffmpeg_exit(1);
2846
    }
2847
    return 0;
2848
}
2849

    
2850
static int opt_bitrate(const char *opt, const char *arg)
2851
{
2852
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2853

    
2854
    opt_default(opt, arg);
2855

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

    
2859
    return 0;
2860
}
2861

    
2862
static int opt_frame_crop(const char *opt, const char *arg)
2863
{
2864
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2865
    return AVERROR(EINVAL);
2866
}
2867

    
2868
static void opt_frame_size(const char *arg)
2869
{
2870
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2871
        fprintf(stderr, "Incorrect frame size\n");
2872
        ffmpeg_exit(1);
2873
    }
2874
}
2875

    
2876
static int opt_pad(const char *opt, const char *arg) {
2877
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2878
    return -1;
2879
}
2880

    
2881
static void opt_frame_pix_fmt(const char *arg)
2882
{
2883
    if (strcmp(arg, "list")) {
2884
        frame_pix_fmt = av_get_pix_fmt(arg);
2885
        if (frame_pix_fmt == PIX_FMT_NONE) {
2886
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2887
            ffmpeg_exit(1);
2888
        }
2889
    } else {
2890
        show_pix_fmts();
2891
        ffmpeg_exit(0);
2892
    }
2893
}
2894

    
2895
static void opt_frame_aspect_ratio(const char *arg)
2896
{
2897
    int x = 0, y = 0;
2898
    double ar = 0;
2899
    const char *p;
2900
    char *end;
2901

    
2902
    p = strchr(arg, ':');
2903
    if (p) {
2904
        x = strtol(arg, &end, 10);
2905
        if (end == p)
2906
            y = strtol(end+1, &end, 10);
2907
        if (x > 0 && y > 0)
2908
            ar = (double)x / (double)y;
2909
    } else
2910
        ar = strtod(arg, NULL);
2911

    
2912
    if (!ar) {
2913
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2914
        ffmpeg_exit(1);
2915
    }
2916
    frame_aspect_ratio = ar;
2917
}
2918

    
2919
static int opt_metadata(const char *opt, const char *arg)
2920
{
2921
    char *mid= strchr(arg, '=');
2922

    
2923
    if(!mid){
2924
        fprintf(stderr, "Missing =\n");
2925
        ffmpeg_exit(1);
2926
    }
2927
    *mid++= 0;
2928

    
2929
    av_metadata_set2(&metadata, arg, mid, 0);
2930

    
2931
    return 0;
2932
}
2933

    
2934
static int opt_qscale(const char *opt, const char *arg)
2935
{
2936
    video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2937
    if (video_qscale <= 0 || video_qscale > 255) {
2938
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2939
        return AVERROR(EINVAL);
2940
    }
2941
    return 0;
2942
}
2943

    
2944
static int opt_top_field_first(const char *opt, const char *arg)
2945
{
2946
    top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2947
    return 0;
2948
}
2949

    
2950
static int opt_thread_count(const char *opt, const char *arg)
2951
{
2952
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2953
#if !HAVE_THREADS
2954
    if (verbose >= 0)
2955
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2956
#endif
2957
    return 0;
2958
}
2959

    
2960
static void opt_audio_sample_fmt(const char *arg)
2961
{
2962
    if (strcmp(arg, "list")) {
2963
        audio_sample_fmt = av_get_sample_fmt(arg);
2964
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2965
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2966
            ffmpeg_exit(1);
2967
        }
2968
    } else {
2969
        int i;
2970
        char fmt_str[128];
2971
        for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2972
            printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2973
        ffmpeg_exit(0);
2974
    }
2975
}
2976

    
2977
static int opt_audio_rate(const char *opt, const char *arg)
2978
{
2979
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2980
    return 0;
2981
}
2982

    
2983
static int opt_audio_channels(const char *opt, const char *arg)
2984
{
2985
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2986
    return 0;
2987
}
2988

    
2989
static int opt_video_channel(const char *opt, const char *arg)
2990
{
2991
    video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2992
    return 0;
2993
}
2994

    
2995
static void opt_video_standard(const char *arg)
2996
{
2997
    video_standard = av_strdup(arg);
2998
}
2999

    
3000
static void opt_codec(int *pstream_copy, char **pcodec_name,
3001
                      int codec_type, const char *arg)
3002
{
3003
    av_freep(pcodec_name);
3004
    if (!strcmp(arg, "copy")) {
3005
        *pstream_copy = 1;
3006
    } else {
3007
        *pcodec_name = av_strdup(arg);
3008
    }
3009
}
3010

    
3011
static void opt_audio_codec(const char *arg)
3012
{
3013
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
3014
}
3015

    
3016
static void opt_video_codec(const char *arg)
3017
{
3018
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
3019
}
3020

    
3021
static void opt_subtitle_codec(const char *arg)
3022
{
3023
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3024
}
3025

    
3026
static int opt_codec_tag(const char *opt, const char *arg)
3027
{
3028
    char *tail;
3029
    uint32_t *codec_tag;
3030

    
3031
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3032
                !strcmp(opt, "vtag") ? &video_codec_tag :
3033
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3034
    if (!codec_tag)
3035
        return -1;
3036

    
3037
    *codec_tag = strtol(arg, &tail, 0);
3038
    if (!tail || *tail)
3039
        *codec_tag = AV_RL32(arg);
3040

    
3041
    return 0;
3042
}
3043

    
3044
static void opt_map(const char *arg)
3045
{
3046
    AVStreamMap *m;
3047
    char *p;
3048

    
3049
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3050
    m = &stream_maps[nb_stream_maps-1];
3051

    
3052
    m->file_index = strtol(arg, &p, 0);
3053
    if (*p)
3054
        p++;
3055

    
3056
    m->stream_index = strtol(p, &p, 0);
3057
    if (*p) {
3058
        p++;
3059
        m->sync_file_index = strtol(p, &p, 0);
3060
        if (*p)
3061
            p++;
3062
        m->sync_stream_index = strtol(p, &p, 0);
3063
    } else {
3064
        m->sync_file_index = m->file_index;
3065
        m->sync_stream_index = m->stream_index;
3066
    }
3067
}
3068

    
3069
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3070
{
3071
    *endptr = arg;
3072
    if (*arg == ',') {
3073
        *type = *(++arg);
3074
        switch (*arg) {
3075
        case 'g':
3076
            break;
3077
        case 's':
3078
        case 'c':
3079
        case 'p':
3080
            *index = strtol(++arg, endptr, 0);
3081
            break;
3082
        default:
3083
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3084
            ffmpeg_exit(1);
3085
        }
3086
    } else
3087
        *type = 'g';
3088
}
3089

    
3090
static void opt_map_metadata(const char *arg)
3091
{
3092
    AVMetaDataMap *m, *m1;
3093
    char *p;
3094

    
3095
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3096
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3097

    
3098
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3099
    m->file = strtol(arg, &p, 0);
3100
    parse_meta_type(p, &m->type, &m->index, &p);
3101
    if (*p)
3102
        p++;
3103

    
3104
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3105
    m1->file = strtol(p, &p, 0);
3106
    parse_meta_type(p, &m1->type, &m1->index, &p);
3107

    
3108
    if (m->type == 'g' || m1->type == 'g')
3109
        metadata_global_autocopy = 0;
3110
    if (m->type == 's' || m1->type == 's')
3111
        metadata_streams_autocopy = 0;
3112
    if (m->type == 'c' || m1->type == 'c')
3113
        metadata_chapters_autocopy = 0;
3114
}
3115

    
3116
static void opt_map_meta_data(const char *arg)
3117
{
3118
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3119
                    "Use -map_metadata instead.\n");
3120
    opt_map_metadata(arg);
3121
}
3122

    
3123
static void opt_map_chapters(const char *arg)
3124
{
3125
    AVChapterMap *c;
3126
    char *p;
3127

    
3128
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3129
                              nb_chapter_maps + 1);
3130
    c = &chapter_maps[nb_chapter_maps - 1];
3131
    c->out_file = strtol(arg, &p, 0);
3132
    if (*p)
3133
        p++;
3134

    
3135
    c->in_file = strtol(p, &p, 0);
3136
}
3137

    
3138
static void opt_input_ts_scale(const char *arg)
3139
{
3140
    unsigned int stream;
3141
    double scale;
3142
    char *p;
3143

    
3144
    stream = strtol(arg, &p, 0);
3145
    if (*p)
3146
        p++;
3147
    scale= strtod(p, &p);
3148

    
3149
    if(stream >= MAX_STREAMS)
3150
        ffmpeg_exit(1);
3151

    
3152
    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);
3153
    input_files_ts_scale[nb_input_files][stream]= scale;
3154
}
3155

    
3156
static int opt_recording_time(const char *opt, const char *arg)
3157
{
3158
    recording_time = parse_time_or_die(opt, arg, 1);
3159
    return 0;
3160
}
3161

    
3162
static int opt_start_time(const char *opt, const char *arg)
3163
{
3164
    start_time = parse_time_or_die(opt, arg, 1);
3165
    return 0;
3166
}
3167

    
3168
static int opt_recording_timestamp(const char *opt, const char *arg)
3169
{
3170
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3171
    return 0;
3172
}
3173

    
3174
static int opt_input_ts_offset(const char *opt, const char *arg)
3175
{
3176
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3177
    return 0;
3178
}
3179

    
3180
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3181
{
3182
    const char *codec_string = encoder ? "encoder" : "decoder";
3183
    AVCodec *codec;
3184

    
3185
    if(!name)
3186
        return CODEC_ID_NONE;
3187
    codec = encoder ?
3188
        avcodec_find_encoder_by_name(name) :
3189
        avcodec_find_decoder_by_name(name);
3190
    if(!codec) {
3191
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3192
        ffmpeg_exit(1);
3193
    }
3194
    if(codec->type != type) {
3195
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3196
        ffmpeg_exit(1);
3197
    }
3198
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3199
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3200
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3201
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3202
                codec_string, codec->name);
3203
        codec = encoder ?
3204
            avcodec_find_encoder(codec->id) :
3205
            avcodec_find_decoder(codec->id);
3206
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3207
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3208
                    codec_string, codec->name);
3209
        ffmpeg_exit(1);
3210
    }
3211
    return codec->id;
3212
}
3213

    
3214
static void opt_input_file(const char *filename)
3215
{
3216
    AVFormatContext *ic;
3217
    AVFormatParameters params, *ap = &params;
3218
    AVInputFormat *file_iformat = NULL;
3219
    int err, i, ret, rfps, rfps_base;
3220
    int64_t timestamp;
3221

    
3222
    if (last_asked_format) {
3223
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3224
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3225
            ffmpeg_exit(1);
3226
        }
3227
        last_asked_format = NULL;
3228
    }
3229

    
3230
    if (!strcmp(filename, "-"))
3231
        filename = "pipe:";
3232

    
3233
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3234
                    !strcmp(filename, "/dev/stdin");
3235

    
3236
    /* get default parameters from command line */
3237
    ic = avformat_alloc_context();
3238
    if (!ic) {
3239
        print_error(filename, AVERROR(ENOMEM));
3240
        ffmpeg_exit(1);
3241
    }
3242

    
3243
    memset(ap, 0, sizeof(*ap));
3244
    ap->prealloced_context = 1;
3245
    ap->sample_rate = audio_sample_rate;
3246
    ap->channels = audio_channels;
3247
    ap->time_base.den = frame_rate.num;
3248
    ap->time_base.num = frame_rate.den;
3249
    ap->width = frame_width;
3250
    ap->height = frame_height;
3251
    ap->pix_fmt = frame_pix_fmt;
3252
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3253
    ap->channel = video_channel;
3254
    ap->standard = video_standard;
3255

    
3256
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3257

    
3258
    ic->video_codec_id   =
3259
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3260
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3261
    ic->audio_codec_id   =
3262
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3263
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3264
    ic->subtitle_codec_id=
3265
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3266
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3267
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3268

    
3269
    /* open the input file with generic libav function */
3270
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3271
    if (err < 0) {
3272
        print_error(filename, err);
3273
        ffmpeg_exit(1);
3274
    }
3275
    if(opt_programid) {
3276
        int i, j;
3277
        int found=0;
3278
        for(i=0; i<ic->nb_streams; i++){
3279
            ic->streams[i]->discard= AVDISCARD_ALL;
3280
        }
3281
        for(i=0; i<ic->nb_programs; i++){
3282
            AVProgram *p= ic->programs[i];
3283
            if(p->id != opt_programid){
3284
                p->discard = AVDISCARD_ALL;
3285
            }else{
3286
                found=1;
3287
                for(j=0; j<p->nb_stream_indexes; j++){
3288
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3289
                }
3290
            }
3291
        }
3292
        if(!found){
3293
            fprintf(stderr, "Specified program id not found\n");
3294
            ffmpeg_exit(1);
3295
        }
3296
        opt_programid=0;
3297
    }
3298

    
3299
    ic->loop_input = loop_input;
3300

    
3301
    /* If not enough info to get the stream parameters, we decode the
3302
       first frames to get it. (used in mpeg case for example) */
3303
    ret = av_find_stream_info(ic);
3304
    if (ret < 0 && verbose >= 0) {
3305
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3306
        av_close_input_file(ic);
3307
        ffmpeg_exit(1);
3308
    }
3309

    
3310
    timestamp = start_time;
3311
    /* add the stream start time */
3312
    if (ic->start_time != AV_NOPTS_VALUE)
3313
        timestamp += ic->start_time;
3314

    
3315
    /* if seeking requested, we execute it */
3316
    if (start_time != 0) {
3317
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3318
        if (ret < 0) {
3319
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3320
                    filename, (double)timestamp / AV_TIME_BASE);
3321
        }
3322
        /* reset seek info */
3323
        start_time = 0;
3324
    }
3325

    
3326
    /* update the current parameters so that they match the one of the input stream */
3327
    for(i=0;i<ic->nb_streams;i++) {
3328
        AVStream *st = ic->streams[i];
3329
        AVCodecContext *dec = st->codec;
3330
        dec->thread_count = thread_count;
3331
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3332
        switch (dec->codec_type) {
3333
        case AVMEDIA_TYPE_AUDIO:
3334
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3335
            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]);
3336
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3337
            channel_layout    = dec->channel_layout;
3338
            audio_channels    = dec->channels;
3339
            audio_sample_rate = dec->sample_rate;
3340
            audio_sample_fmt  = dec->sample_fmt;
3341
            if(audio_disable)
3342
                st->discard= AVDISCARD_ALL;
3343
            /* Note that av_find_stream_info can add more streams, and we
3344
             * currently have no chance of setting up lowres decoding
3345
             * early enough for them. */
3346
            if (dec->lowres)
3347
                audio_sample_rate >>= dec->lowres;
3348
            break;
3349
        case AVMEDIA_TYPE_VIDEO:
3350
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3351
            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]);
3352
            frame_height = dec->height;
3353
            frame_width  = dec->width;
3354
            frame_pix_fmt = dec->pix_fmt;
3355
            rfps      = ic->streams[i]->r_frame_rate.num;
3356
            rfps_base = ic->streams[i]->r_frame_rate.den;
3357
            if (dec->lowres) {
3358
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3359
                frame_height >>= dec->lowres;
3360
                frame_width  >>= dec->lowres;
3361
                dec->height = frame_height;
3362
                dec->width  = frame_width;
3363
            }
3364
            if(me_threshold)
3365
                dec->debug |= FF_DEBUG_MV;
3366

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

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

    
3373
                    (float)rfps / rfps_base, rfps, rfps_base);
3374
            }
3375
            /* update the current frame rate to match the stream frame rate */
3376
            frame_rate.num = rfps;
3377
            frame_rate.den = rfps_base;
3378

    
3379
            if(video_disable)
3380
                st->discard= AVDISCARD_ALL;
3381
            else if(video_discard)
3382
                st->discard= video_discard;
3383
            break;
3384
        case AVMEDIA_TYPE_DATA:
3385
            break;
3386
        case AVMEDIA_TYPE_SUBTITLE:
3387
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3388
            if(subtitle_disable)
3389
                st->discard = AVDISCARD_ALL;
3390
            break;
3391
        case AVMEDIA_TYPE_ATTACHMENT:
3392
        case AVMEDIA_TYPE_UNKNOWN:
3393
            break;
3394
        default:
3395
            abort();
3396
        }
3397
    }
3398

    
3399
    input_files[nb_input_files] = ic;
3400
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3401
    /* dump the file content */
3402
    if (verbose >= 0)
3403
        av_dump_format(ic, nb_input_files, filename, 0);
3404

    
3405
    nb_input_files++;
3406

    
3407
    video_channel = 0;
3408

    
3409
    av_freep(&video_codec_name);
3410
    av_freep(&audio_codec_name);
3411
    av_freep(&subtitle_codec_name);
3412
}
3413

    
3414
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3415
                                         int *has_subtitle_ptr)
3416
{
3417
    int has_video, has_audio, has_subtitle, i, j;
3418
    AVFormatContext *ic;
3419

    
3420
    has_video = 0;
3421
    has_audio = 0;
3422
    has_subtitle = 0;
3423
    for(j=0;j<nb_input_files;j++) {
3424
        ic = input_files[j];
3425
        for(i=0;i<ic->nb_streams;i++) {
3426
            AVCodecContext *enc = ic->streams[i]->codec;
3427
            switch(enc->codec_type) {
3428
            case AVMEDIA_TYPE_AUDIO:
3429
                has_audio = 1;
3430
                break;
3431
            case AVMEDIA_TYPE_VIDEO:
3432
                has_video = 1;
3433
                break;
3434
            case AVMEDIA_TYPE_SUBTITLE:
3435
                has_subtitle = 1;
3436
                break;
3437
            case AVMEDIA_TYPE_DATA:
3438
            case AVMEDIA_TYPE_ATTACHMENT:
3439
            case AVMEDIA_TYPE_UNKNOWN:
3440
                break;
3441
            default:
3442
                abort();
3443
            }
3444
        }
3445
    }
3446
    *has_video_ptr = has_video;
3447
    *has_audio_ptr = has_audio;
3448
    *has_subtitle_ptr = has_subtitle;
3449
}
3450

    
3451
static void new_video_stream(AVFormatContext *oc, int file_idx)
3452
{
3453
    AVStream *st;
3454
    AVOutputStream *ost;
3455
    AVCodecContext *video_enc;
3456
    enum CodecID codec_id = CODEC_ID_NONE;
3457
    AVCodec *codec= NULL;
3458

    
3459
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3460
    if (!st) {
3461
        fprintf(stderr, "Could not alloc stream\n");
3462
        ffmpeg_exit(1);
3463
    }
3464
    ost = new_output_stream(oc, file_idx);
3465

    
3466
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3467
    if(!video_stream_copy){
3468
        if (video_codec_name) {
3469
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3470
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3471
            codec = avcodec_find_encoder_by_name(video_codec_name);
3472
            output_codecs[nb_output_codecs-1] = codec;
3473
        } else {
3474
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3475
            codec = avcodec_find_encoder(codec_id);
3476
        }
3477
        ost->frame_aspect_ratio = frame_aspect_ratio;
3478
        frame_aspect_ratio = 0;
3479
#if CONFIG_AVFILTER
3480
        ost->avfilter= vfilters;
3481
        vfilters= NULL;
3482
#endif
3483
    }
3484

    
3485
    avcodec_get_context_defaults3(st->codec, codec);
3486
    ost->bitstream_filters = video_bitstream_filters;
3487
    video_bitstream_filters= NULL;
3488

    
3489
    st->codec->thread_count= thread_count;
3490

    
3491
    video_enc = st->codec;
3492

    
3493
    if(video_codec_tag)
3494
        video_enc->codec_tag= video_codec_tag;
3495

    
3496
    if(   (video_global_header&1)
3497
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3498
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3499
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3500
    }
3501
    if(video_global_header&2){
3502
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3503
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3504
    }
3505

    
3506
    if (video_stream_copy) {
3507
        st->stream_copy = 1;
3508
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3509
        video_enc->sample_aspect_ratio =
3510
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3511
    } else {
3512
        const char *p;
3513
        int i;
3514
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3515

    
3516
        video_enc->codec_id = codec_id;
3517
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3518

    
3519
        if (codec && codec->supported_framerates && !force_fps)
3520
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3521
        video_enc->time_base.den = fps.num;
3522
        video_enc->time_base.num = fps.den;
3523

    
3524
        video_enc->width = frame_width;
3525
        video_enc->height = frame_height;
3526
        video_enc->pix_fmt = frame_pix_fmt;
3527
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3528
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3529

    
3530
        choose_pixel_fmt(st, codec);
3531

    
3532
        if (intra_only)
3533
            video_enc->gop_size = 0;
3534
        if (video_qscale || same_quality) {
3535
            video_enc->flags |= CODEC_FLAG_QSCALE;
3536
            video_enc->global_quality=
3537
                st->quality = FF_QP2LAMBDA * video_qscale;
3538
        }
3539

    
3540
        if(intra_matrix)
3541
            video_enc->intra_matrix = intra_matrix;
3542
        if(inter_matrix)
3543
            video_enc->inter_matrix = inter_matrix;
3544

    
3545
        p= video_rc_override_string;
3546
        for(i=0; p; i++){
3547
            int start, end, q;
3548
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3549
            if(e!=3){
3550
                fprintf(stderr, "error parsing rc_override\n");
3551
                ffmpeg_exit(1);
3552
            }
3553
            video_enc->rc_override=
3554
                av_realloc(video_enc->rc_override,
3555
                           sizeof(RcOverride)*(i+1));
3556
            video_enc->rc_override[i].start_frame= start;
3557
            video_enc->rc_override[i].end_frame  = end;
3558
            if(q>0){
3559
                video_enc->rc_override[i].qscale= q;
3560
                video_enc->rc_override[i].quality_factor= 1.0;
3561
            }
3562
            else{
3563
                video_enc->rc_override[i].qscale= 0;
3564
                video_enc->rc_override[i].quality_factor= -q/100.0;
3565
            }
3566
            p= strchr(p, '/');
3567
            if(p) p++;
3568
        }
3569
        video_enc->rc_override_count=i;
3570
        if (!video_enc->rc_initial_buffer_occupancy)
3571
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3572
        video_enc->me_threshold= me_threshold;
3573
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3574

    
3575
        if (do_psnr)
3576
            video_enc->flags|= CODEC_FLAG_PSNR;
3577

    
3578
        /* two pass mode */
3579
        if (do_pass) {
3580
            if (do_pass == 1) {
3581
                video_enc->flags |= CODEC_FLAG_PASS1;
3582
            } else {
3583
                video_enc->flags |= CODEC_FLAG_PASS2;
3584
            }
3585
        }
3586

    
3587
        if (forced_key_frames)
3588
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3589
    }
3590
    if (video_language) {
3591
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3592
        av_freep(&video_language);
3593
    }
3594

    
3595
    /* reset some key parameters */
3596
    video_disable = 0;
3597
    av_freep(&video_codec_name);
3598
    av_freep(&forced_key_frames);
3599
    video_stream_copy = 0;
3600
    frame_pix_fmt = PIX_FMT_NONE;
3601
}
3602

    
3603
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3604
{
3605
    AVStream *st;
3606
    AVOutputStream *ost;
3607
    AVCodec *codec= NULL;
3608
    AVCodecContext *audio_enc;
3609
    enum CodecID codec_id = CODEC_ID_NONE;
3610

    
3611
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3612
    if (!st) {
3613
        fprintf(stderr, "Could not alloc stream\n");
3614
        ffmpeg_exit(1);
3615
    }
3616
    ost = new_output_stream(oc, file_idx);
3617

    
3618
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3619
    if(!audio_stream_copy){
3620
        if (audio_codec_name) {
3621
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3622
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3623
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3624
            output_codecs[nb_output_codecs-1] = codec;
3625
        } else {
3626
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3627
            codec = avcodec_find_encoder(codec_id);
3628
        }
3629
    }
3630

    
3631
    avcodec_get_context_defaults3(st->codec, codec);
3632

    
3633
    ost->bitstream_filters = audio_bitstream_filters;
3634
    audio_bitstream_filters= NULL;
3635

    
3636
    st->codec->thread_count= thread_count;
3637

    
3638
    audio_enc = st->codec;
3639
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3640

    
3641
    if(audio_codec_tag)
3642
        audio_enc->codec_tag= audio_codec_tag;
3643

    
3644
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3645
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3646
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3647
    }
3648
    if (audio_stream_copy) {
3649
        st->stream_copy = 1;
3650
        audio_enc->channels = audio_channels;
3651
        audio_enc->sample_rate = audio_sample_rate;
3652
    } else {
3653
        audio_enc->codec_id = codec_id;
3654
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3655

    
3656
        if (audio_qscale > QSCALE_NONE) {
3657
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3658
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3659
        }
3660
        audio_enc->channels = audio_channels;
3661
        audio_enc->sample_fmt = audio_sample_fmt;
3662
        audio_enc->sample_rate = audio_sample_rate;
3663
        audio_enc->channel_layout = channel_layout;
3664
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3665
            audio_enc->channel_layout = 0;
3666
        choose_sample_fmt(st, codec);
3667
        choose_sample_rate(st, codec);
3668
    }
3669
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3670
    if (audio_language) {
3671
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3672
        av_freep(&audio_language);
3673
    }
3674

    
3675
    /* reset some key parameters */
3676
    audio_disable = 0;
3677
    av_freep(&audio_codec_name);
3678
    audio_stream_copy = 0;
3679
}
3680

    
3681
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3682
{
3683
    AVStream *st;
3684
    AVOutputStream *ost;
3685
    AVCodec *codec=NULL;
3686
    AVCodecContext *subtitle_enc;
3687
    enum CodecID codec_id = CODEC_ID_NONE;
3688

    
3689
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3690
    if (!st) {
3691
        fprintf(stderr, "Could not alloc stream\n");
3692
        ffmpeg_exit(1);
3693
    }
3694
    ost = new_output_stream(oc, file_idx);
3695
    subtitle_enc = st->codec;
3696
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3697
    if(!subtitle_stream_copy){
3698
        if (subtitle_codec_name) {
3699
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3700
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3701
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3702
        } else {
3703
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3704
            codec = avcodec_find_encoder(codec_id);
3705
        }
3706
    }
3707
    avcodec_get_context_defaults3(st->codec, codec);
3708

    
3709
    ost->bitstream_filters = subtitle_bitstream_filters;
3710
    subtitle_bitstream_filters= NULL;
3711

    
3712
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3713

    
3714
    if(subtitle_codec_tag)
3715
        subtitle_enc->codec_tag= subtitle_codec_tag;
3716

    
3717
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3718
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3719
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3720
    }
3721
    if (subtitle_stream_copy) {
3722
        st->stream_copy = 1;
3723
    } else {
3724
        subtitle_enc->codec_id = codec_id;
3725
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3726
    }
3727

    
3728
    if (subtitle_language) {
3729
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3730
        av_freep(&subtitle_language);
3731
    }
3732

    
3733
    subtitle_disable = 0;
3734
    av_freep(&subtitle_codec_name);
3735
    subtitle_stream_copy = 0;
3736
}
3737

    
3738
static int opt_new_stream(const char *opt, const char *arg)
3739
{
3740
    AVFormatContext *oc;
3741
    int file_idx = nb_output_files - 1;
3742
    if (nb_output_files <= 0) {
3743
        fprintf(stderr, "At least one output file must be specified\n");
3744
        ffmpeg_exit(1);
3745
    }
3746
    oc = output_files[file_idx];
3747

    
3748
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3749
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3750
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3751
    else av_assert0(0);
3752
    return 0;
3753
}
3754

    
3755
/* arg format is "output-stream-index:streamid-value". */
3756
static int opt_streamid(const char *opt, const char *arg)
3757
{
3758
    int idx;
3759
    char *p;
3760
    char idx_str[16];
3761

    
3762
    strncpy(idx_str, arg, sizeof(idx_str));
3763
    idx_str[sizeof(idx_str)-1] = '\0';
3764
    p = strchr(idx_str, ':');
3765
    if (!p) {
3766
        fprintf(stderr,
3767
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3768
                arg, opt);
3769
        ffmpeg_exit(1);
3770
    }
3771
    *p++ = '\0';
3772
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3773
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3774
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3775
    return 0;
3776
}
3777

    
3778
static void opt_output_file(const char *filename)
3779
{
3780
    AVFormatContext *oc;
3781
    int err, use_video, use_audio, use_subtitle;
3782
    int input_has_video, input_has_audio, input_has_subtitle;
3783
    AVFormatParameters params, *ap = &params;
3784
    AVOutputFormat *file_oformat;
3785

    
3786
    if (!strcmp(filename, "-"))
3787
        filename = "pipe:";
3788

    
3789
    oc = avformat_alloc_context();
3790
    if (!oc) {
3791
        print_error(filename, AVERROR(ENOMEM));
3792
        ffmpeg_exit(1);
3793
    }
3794

    
3795
    if (last_asked_format) {
3796
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3797
        if (!file_oformat) {
3798
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3799
            ffmpeg_exit(1);
3800
        }
3801
        last_asked_format = NULL;
3802
    } else {
3803
        file_oformat = av_guess_format(NULL, filename, NULL);
3804
        if (!file_oformat) {
3805
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3806
                    filename);
3807
            ffmpeg_exit(1);
3808
        }
3809
    }
3810

    
3811
    oc->oformat = file_oformat;
3812
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3813

    
3814
    if (!strcmp(file_oformat->name, "ffm") &&
3815
        av_strstart(filename, "http:", NULL)) {
3816
        /* special case for files sent to ffserver: we get the stream
3817
           parameters from ffserver */
3818
        int err = read_ffserver_streams(oc, filename);
3819
        if (err < 0) {
3820
            print_error(filename, err);
3821
            ffmpeg_exit(1);
3822
        }
3823
    } else {
3824
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3825
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3826
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3827

    
3828
        /* disable if no corresponding type found and at least one
3829
           input file */
3830
        if (nb_input_files > 0) {
3831
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3832
                                         &input_has_subtitle);
3833
            if (!input_has_video)
3834
                use_video = 0;
3835
            if (!input_has_audio)
3836
                use_audio = 0;
3837
            if (!input_has_subtitle)
3838
                use_subtitle = 0;
3839
        }
3840

    
3841
        /* manual disable */
3842
        if (audio_disable)    use_audio    = 0;
3843
        if (video_disable)    use_video    = 0;
3844
        if (subtitle_disable) use_subtitle = 0;
3845

    
3846
        if (use_video)    new_video_stream(oc, nb_output_files);
3847
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3848
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3849

    
3850
        oc->timestamp = recording_timestamp;
3851

    
3852
        av_metadata_copy(&oc->metadata, metadata, 0);
3853
        av_metadata_free(&metadata);
3854
    }
3855

    
3856
    output_files[nb_output_files++] = oc;
3857

    
3858
    /* check filename in case of an image number is expected */
3859
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3860
        if (!av_filename_number_test(oc->filename)) {
3861
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3862
            ffmpeg_exit(1);
3863
        }
3864
    }
3865

    
3866
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3867
        /* test if it already exists to avoid loosing precious files */
3868
        if (!file_overwrite &&
3869
            (strchr(filename, ':') == NULL ||
3870
             filename[1] == ':' ||
3871
             av_strstart(filename, "file:", NULL))) {
3872
            if (url_exist(filename)) {
3873
                if (!using_stdin) {
3874
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3875
                    fflush(stderr);
3876
                    if (!read_yesno()) {
3877
                        fprintf(stderr, "Not overwriting - exiting\n");
3878
                        ffmpeg_exit(1);
3879
                    }
3880
                }
3881
                else {
3882
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3883
                    ffmpeg_exit(1);
3884
                }
3885
            }
3886
        }
3887

    
3888
        /* open the file */
3889
        if ((err = avio_open(&oc->pb, filename, AVIO_WRONLY)) < 0) {
3890
            print_error(filename, err);
3891
            ffmpeg_exit(1);
3892
        }
3893
    }
3894

    
3895
    memset(ap, 0, sizeof(*ap));
3896
    if (av_set_parameters(oc, ap) < 0) {
3897
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3898
                oc->filename);
3899
        ffmpeg_exit(1);
3900
    }
3901

    
3902
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3903
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3904
    oc->loop_output = loop_output;
3905

    
3906
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3907

    
3908
    av_freep(&forced_key_frames);
3909
}
3910

    
3911
/* same option as mencoder */
3912
static int opt_pass(const char *opt, const char *arg)
3913
{
3914
    do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3915
    return 0;
3916
}
3917

    
3918
static int64_t getutime(void)
3919
{
3920
#if HAVE_GETRUSAGE
3921
    struct rusage rusage;
3922

    
3923
    getrusage(RUSAGE_SELF, &rusage);
3924
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3925
#elif HAVE_GETPROCESSTIMES
3926
    HANDLE proc;
3927
    FILETIME c, e, k, u;
3928
    proc = GetCurrentProcess();
3929
    GetProcessTimes(proc, &c, &e, &k, &u);
3930
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3931
#else
3932
    return av_gettime();
3933
#endif
3934
}
3935

    
3936
static int64_t getmaxrss(void)
3937
{
3938
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3939
    struct rusage rusage;
3940
    getrusage(RUSAGE_SELF, &rusage);
3941
    return (int64_t)rusage.ru_maxrss * 1024;
3942
#elif HAVE_GETPROCESSMEMORYINFO
3943
    HANDLE proc;
3944
    PROCESS_MEMORY_COUNTERS memcounters;
3945
    proc = GetCurrentProcess();
3946
    memcounters.cb = sizeof(memcounters);
3947
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3948
    return memcounters.PeakPagefileUsage;
3949
#else
3950
    return 0;
3951
#endif
3952
}
3953

    
3954
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3955
{
3956
    int i;
3957
    const char *p = str;
3958
    for(i = 0;; i++) {
3959
        dest[i] = atoi(p);
3960
        if(i == 63)
3961
            break;
3962
        p = strchr(p, ',');
3963
        if(!p) {
3964
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3965
            ffmpeg_exit(1);
3966
        }
3967
        p++;
3968
    }
3969
}
3970

    
3971
static void opt_inter_matrix(const char *arg)
3972
{
3973
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3974
    parse_matrix_coeffs(inter_matrix, arg);
3975
}
3976

    
3977
static void opt_intra_matrix(const char *arg)
3978
{
3979
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3980
    parse_matrix_coeffs(intra_matrix, arg);
3981
}
3982

    
3983
static void show_usage(void)
3984
{
3985
    printf("Hyper fast Audio and Video encoder\n");
3986
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3987
    printf("\n");
3988
}
3989

    
3990
static void show_help(void)
3991
{
3992
    AVCodec *c;
3993
    AVOutputFormat *oformat = NULL;
3994

    
3995
    av_log_set_callback(log_callback_help);
3996
    show_usage();
3997
    show_help_options(options, "Main options:\n",
3998
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3999
    show_help_options(options, "\nAdvanced options:\n",
4000
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4001
                      OPT_EXPERT);
4002
    show_help_options(options, "\nVideo options:\n",
4003
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4004
                      OPT_VIDEO);
4005
    show_help_options(options, "\nAdvanced Video options:\n",
4006
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4007
                      OPT_VIDEO | OPT_EXPERT);
4008
    show_help_options(options, "\nAudio options:\n",
4009
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4010
                      OPT_AUDIO);
4011
    show_help_options(options, "\nAdvanced Audio options:\n",
4012
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4013
                      OPT_AUDIO | OPT_EXPERT);
4014
    show_help_options(options, "\nSubtitle options:\n",
4015
                      OPT_SUBTITLE | OPT_GRAB,
4016
                      OPT_SUBTITLE);
4017
    show_help_options(options, "\nAudio/Video grab options:\n",
4018
                      OPT_GRAB,
4019
                      OPT_GRAB);
4020
    printf("\n");
4021
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4022
    printf("\n");
4023

    
4024
    /* individual codec options */
4025
    c = NULL;
4026
    while ((c = av_codec_next(c))) {
4027
        if (c->priv_class) {
4028
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4029
            printf("\n");
4030
        }
4031
    }
4032

    
4033
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4034
    printf("\n");
4035

    
4036
    /* individual muxer options */
4037
    while ((oformat = av_oformat_next(oformat))) {
4038
        if (oformat->priv_class) {
4039
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4040
            printf("\n");
4041
        }
4042
    }
4043

    
4044
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4045
}
4046

    
4047
static void opt_target(const char *arg)
4048
{
4049
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4050
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4051

    
4052
    if(!strncmp(arg, "pal-", 4)) {
4053
        norm = PAL;
4054
        arg += 4;
4055
    } else if(!strncmp(arg, "ntsc-", 5)) {
4056
        norm = NTSC;
4057
        arg += 5;
4058
    } else if(!strncmp(arg, "film-", 5)) {
4059
        norm = FILM;
4060
        arg += 5;
4061
    } else {
4062
        int fr;
4063
        /* Calculate FR via float to avoid int overflow */
4064
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4065
        if(fr == 25000) {
4066
            norm = PAL;
4067
        } else if((fr == 29970) || (fr == 23976)) {
4068
            norm = NTSC;
4069
        } else {
4070
            /* Try to determine PAL/NTSC by peeking in the input files */
4071
            if(nb_input_files) {
4072
                int i, j;
4073
                for(j = 0; j < nb_input_files; j++) {
4074
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
4075
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
4076
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4077
                            continue;
4078
                        fr = c->time_base.den * 1000 / c->time_base.num;
4079
                        if(fr == 25000) {
4080
                            norm = PAL;
4081
                            break;
4082
                        } else if((fr == 29970) || (fr == 23976)) {
4083
                            norm = NTSC;
4084
                            break;
4085
                        }
4086
                    }
4087
                    if(norm != UNKNOWN)
4088
                        break;
4089
                }
4090
            }
4091
        }
4092
        if(verbose && norm != UNKNOWN)
4093
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4094
    }
4095

    
4096
    if(norm == UNKNOWN) {
4097
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4098
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4099
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4100
        ffmpeg_exit(1);
4101
    }
4102

    
4103
    if(!strcmp(arg, "vcd")) {
4104

    
4105
        opt_video_codec("mpeg1video");
4106
        opt_audio_codec("mp2");
4107
        opt_format("vcd");
4108

    
4109
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4110
        opt_frame_rate(NULL, frame_rates[norm]);
4111
        opt_default("g", norm == PAL ? "15" : "18");
4112

    
4113
        opt_default("b", "1150000");
4114
        opt_default("maxrate", "1150000");
4115
        opt_default("minrate", "1150000");
4116
        opt_default("bufsize", "327680"); // 40*1024*8;
4117

    
4118
        opt_default("ab", "224000");
4119
        audio_sample_rate = 44100;
4120
        audio_channels = 2;
4121

    
4122
        opt_default("packetsize", "2324");
4123
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4124

    
4125
        /* We have to offset the PTS, so that it is consistent with the SCR.
4126
           SCR starts at 36000, but the first two packs contain only padding
4127
           and the first pack from the other stream, respectively, may also have
4128
           been written before.
4129
           So the real data starts at SCR 36000+3*1200. */
4130
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4131
    } else if(!strcmp(arg, "svcd")) {
4132

    
4133
        opt_video_codec("mpeg2video");
4134
        opt_audio_codec("mp2");
4135
        opt_format("svcd");
4136

    
4137
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4138
        opt_frame_rate(NULL, frame_rates[norm]);
4139
        opt_default("g", norm == PAL ? "15" : "18");
4140

    
4141
        opt_default("b", "2040000");
4142
        opt_default("maxrate", "2516000");
4143
        opt_default("minrate", "0"); //1145000;
4144
        opt_default("bufsize", "1835008"); //224*1024*8;
4145
        opt_default("flags", "+scan_offset");
4146

    
4147

    
4148
        opt_default("ab", "224000");
4149
        audio_sample_rate = 44100;
4150

    
4151
        opt_default("packetsize", "2324");
4152

    
4153
    } else if(!strcmp(arg, "dvd")) {
4154

    
4155
        opt_video_codec("mpeg2video");
4156
        opt_audio_codec("ac3");
4157
        opt_format("dvd");
4158

    
4159
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4160
        opt_frame_rate(NULL, frame_rates[norm]);
4161
        opt_default("g", norm == PAL ? "15" : "18");
4162

    
4163
        opt_default("b", "6000000");
4164
        opt_default("maxrate", "9000000");
4165
        opt_default("minrate", "0"); //1500000;
4166
        opt_default("bufsize", "1835008"); //224*1024*8;
4167

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

    
4171
        opt_default("ab", "448000");
4172
        audio_sample_rate = 48000;
4173

    
4174
    } else if(!strncmp(arg, "dv", 2)) {
4175

    
4176
        opt_format("dv");
4177

    
4178
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4179
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4180
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4181
        opt_frame_rate(NULL, frame_rates[norm]);
4182

    
4183
        audio_sample_rate = 48000;
4184
        audio_channels = 2;
4185

    
4186
    } else {
4187
        fprintf(stderr, "Unknown target: %s\n", arg);
4188
        ffmpeg_exit(1);
4189
    }
4190
}
4191

    
4192
static void opt_vstats_file (const char *arg)
4193
{
4194
    av_free (vstats_filename);
4195
    vstats_filename=av_strdup (arg);
4196
}
4197

    
4198
static void opt_vstats (void)
4199
{
4200
    char filename[40];
4201
    time_t today2 = time(NULL);
4202
    struct tm *today = localtime(&today2);
4203

    
4204
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4205
             today->tm_sec);
4206
    opt_vstats_file(filename);
4207
}
4208

    
4209
static int opt_bsf(const char *opt, const char *arg)
4210
{
4211
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4212
    AVBitStreamFilterContext **bsfp;
4213

    
4214
    if(!bsfc){
4215
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4216
        ffmpeg_exit(1);
4217
    }
4218

    
4219
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4220
          *opt == 'a' ? &audio_bitstream_filters :
4221
                        &subtitle_bitstream_filters;
4222
    while(*bsfp)
4223
        bsfp= &(*bsfp)->next;
4224

    
4225
    *bsfp= bsfc;
4226

    
4227
    return 0;
4228
}
4229

    
4230
static int opt_preset(const char *opt, const char *arg)
4231
{
4232
    FILE *f=NULL;
4233
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4234
    char *codec_name = *opt == 'v' ? video_codec_name :
4235
                       *opt == 'a' ? audio_codec_name :
4236
                                     subtitle_codec_name;
4237

    
4238
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4239
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4240
        ffmpeg_exit(1);
4241
    }
4242

    
4243
    while(!feof(f)){
4244
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4245
        if(line[0] == '#' && !e)
4246
            continue;
4247
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4248
        if(e){
4249
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4250
            ffmpeg_exit(1);
4251
        }
4252
        if(!strcmp(tmp, "acodec")){
4253
            opt_audio_codec(tmp2);
4254
        }else if(!strcmp(tmp, "vcodec")){
4255
            opt_video_codec(tmp2);
4256
        }else if(!strcmp(tmp, "scodec")){
4257
            opt_subtitle_codec(tmp2);
4258
        }else if(opt_default(tmp, tmp2) < 0){
4259
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4260
            ffmpeg_exit(1);
4261
        }
4262
    }
4263

    
4264
    fclose(f);
4265

    
4266
    return 0;
4267
}
4268

    
4269
static const OptionDef options[] = {
4270
    /* main options */
4271
#include "cmdutils_common_opts.h"
4272
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4273
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4274
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4275
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4276
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4277
      "outfile[,metadata]:infile[,metadata]" },
4278
    { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4279
      "outfile[,metadata]:infile[,metadata]" },
4280
    { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4281
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4282
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4283
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4284
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4285
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4286
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4287
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4288
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4289
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4290
      "add timings for benchmarking" },
4291
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4292
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4293
      "dump each input packet" },
4294
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4295
      "when dumping packets, also dump the payload" },
4296
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4297
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4298
    { "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)", "" },
4299
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4300
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4301
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4302
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4303
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4304
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4305
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4306
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4307
    { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4308
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4309
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4310
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4311
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4312
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4313

    
4314
    /* video options */
4315
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4316
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4317
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4318
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4319
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4320
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4321
    { "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" },
4322
    { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4323
    { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4324
    { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4325
    { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4326
    { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4327
    { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4328
    { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4329
    { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4330
    { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4331
    { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4332
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4333
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4334
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4335
    { "qscale", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4336
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4337
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4338
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4339
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4340
      "use same quantizer as source (implies VBR)" },
4341
    { "pass", HAS_ARG | OPT_FUNC2 | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4342
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4343
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4344
      "deinterlace pictures" },
4345
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4346
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4347
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4348
#if CONFIG_AVFILTER
4349
    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4350
#endif
4351
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4352
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4353
    { "top", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4354
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4355
    { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4356
    { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4357
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4358
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4359
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4360
    { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4361
    { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4362

    
4363
    /* audio options */
4364
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4365
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4366
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4367
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4368
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4369
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4370
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4371
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4372
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4373
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4374
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4375
    { "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" },
4376

    
4377
    /* subtitle options */
4378
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4379
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4380
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4381
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4382
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4383

    
4384
    /* grab options */
4385
    { "vc", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4386
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4387
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4388

    
4389
    /* muxer options */
4390
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4391
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4392

    
4393
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4394
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4395
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4396

    
4397
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4398
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4399
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4400
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4401

    
4402
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4403
    { NULL, },
4404
};
4405

    
4406
int main(int argc, char **argv)
4407
{
4408
    int64_t ti;
4409

    
4410
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4411

    
4412
    avcodec_register_all();
4413
#if CONFIG_AVDEVICE
4414
    avdevice_register_all();
4415
#endif
4416
#if CONFIG_AVFILTER
4417
    avfilter_register_all();
4418
#endif
4419
    av_register_all();
4420

    
4421
#if HAVE_ISATTY
4422
    if(isatty(STDIN_FILENO))
4423
        avio_set_interrupt_cb(decode_interrupt_cb);
4424
#endif
4425

    
4426
    init_opts();
4427

    
4428
    show_banner();
4429

    
4430
    /* parse options */
4431
    parse_options(argc, argv, options, opt_output_file);
4432

    
4433
    if(nb_output_files <= 0 && nb_input_files == 0) {
4434
        show_usage();
4435
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4436
        ffmpeg_exit(1);
4437
    }
4438

    
4439
    /* file converter / grab */
4440
    if (nb_output_files <= 0) {
4441
        fprintf(stderr, "At least one output file must be specified\n");
4442
        ffmpeg_exit(1);
4443
    }
4444

    
4445
    if (nb_input_files == 0) {
4446
        fprintf(stderr, "At least one input file must be specified\n");
4447
        ffmpeg_exit(1);
4448
    }
4449

    
4450
    ti = getutime();
4451
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4452
                  stream_maps, nb_stream_maps) < 0)
4453
        ffmpeg_exit(1);
4454
    ti = getutime() - ti;
4455
    if (do_benchmark) {
4456
        int maxrss = getmaxrss() / 1024;
4457
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4458
    }
4459

    
4460
    return ffmpeg_exit(0);
4461
}