Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 5381823e

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

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

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

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

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

    
229
static int rate_emu = 0;
230

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

    
234
static int audio_volume = 256;
235

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

    
251
static float dts_delta_threshold = 10;
252

    
253
static int64_t timer_start;
254

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

    
259
static short *samples;
260

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

    
265
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
266

    
267
struct AVInputStream;
268

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

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

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

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

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

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

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

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

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

    
350
#if HAVE_TERMIOS_H
351

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

    
356
#if CONFIG_AVFILTER
357

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

    
369
    ost->graph = avfilter_graph_alloc();
370

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

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

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

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

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

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

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

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

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

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

    
431
    codec->width  = ost->output_video_filter->inputs[0]->w;
432
    codec->height = ost->output_video_filter->inputs[0]->h;
433
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
434
        ost->output_video_filter->inputs[0]->sample_aspect_ratio;
435

    
436
    return 0;
437
}
438
#endif /* CONFIG_AVFILTER */
439

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

    
448
static volatile int received_sigterm = 0;
449

    
450
static void
451
sigterm_handler(int sig)
452
{
453
    received_sigterm = sig;
454
    q_pressed++;
455
    term_exit();
456
}
457

    
458
static void term_init(void)
459
{
460
#if HAVE_TERMIOS_H
461
    struct termios tty;
462

    
463
    tcgetattr (0, &tty);
464
    oldtty = tty;
465
    atexit(term_exit);
466

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

    
476
    tcsetattr (0, TCSANOW, &tty);
477
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
478
#endif
479

    
480
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
481
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
482
#ifdef SIGXCPU
483
    signal(SIGXCPU, sigterm_handler);
484
#endif
485
}
486

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

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

    
506
        return n;
507
    }
508
#elif HAVE_KBHIT
509
    if(kbhit())
510
        return(getch());
511
#endif
512
    return -1;
513
}
514

    
515
static int decode_interrupt_cb(void)
516
{
517
    q_pressed += read_key() == 'q';
518
    return q_pressed > 1;
519
}
520

    
521
static int ffmpeg_exit(int ret)
522
{
523
    int i;
524

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

    
538
    av_free(intra_matrix);
539
    av_free(inter_matrix);
540

    
541
    if (vstats_file)
542
        fclose(vstats_file);
543
    av_free(vstats_filename);
544

    
545
    av_free(streamid_map);
546
    av_free(input_codecs);
547
    av_free(output_codecs);
548
    av_free(stream_maps);
549
    av_free(meta_data_maps);
550

    
551
    av_free(video_codec_name);
552
    av_free(audio_codec_name);
553
    av_free(subtitle_codec_name);
554

    
555
    av_free(video_standard);
556

    
557
    uninit_opts();
558
    av_free(audio_buf);
559
    av_free(audio_out);
560
    allocated_audio_buf_size= allocated_audio_out_size= 0;
561
    av_free(samples);
562

    
563
#if CONFIG_AVFILTER
564
    avfilter_uninit();
565
#endif
566

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

    
574
    exit(ret); /* not all OS-es handle main() return value */
575
    return ret;
576
}
577

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

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

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

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

    
664
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
665
{
666
    int idx = oc->nb_streams - 1;
667
    AVOutputStream *ost;
668

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

    
685
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
686
{
687
    int i, err;
688
    AVFormatContext *ic;
689
    int nopts = 0;
690

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

    
700
        s->nb_streams++;
701

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

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

    
726
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
727
            nopts = 1;
728

    
729
        new_output_stream(s, nb_output_files);
730
    }
731

    
732
    if (!nopts)
733
        s->timestamp = av_gettime();
734

    
735
    av_close_input_file(ic);
736
    return 0;
737
}
738

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

    
746
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
747
    int ret;
748

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

    
768
        bsfc= bsfc->next;
769
    }
770

    
771
    ret= av_interleaved_write_frame(s, pkt);
772
    if(ret < 0){
773
        print_error("av_interleaved_write_frame()", ret);
774
        ffmpeg_exit(1);
775
    }
776
}
777

    
778
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
779

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

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

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

    
803
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
804
    if(coded_bps > 8*osize)
805
        audio_out_size= audio_out_size * coded_bps / (8*osize);
806
    audio_out_size += FF_MIN_BUFFER_SIZE;
807

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

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

    
820
    if (enc->channels != dec->channels)
821
        ost->audio_resample = 1;
822

    
823
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
824
                       ost->resample_channels    != dec->channels   ||
825
                       ost->resample_sample_rate != dec->sample_rate;
826

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

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

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

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

    
900
                    if(byte_delta > allocated_for_size - size){
901
                        allocated_for_size= byte_delta + (int64_t)size;
902
                        goto need_realloc;
903
                    }
904
                    ist->is_start=0;
905

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

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

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

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

    
962
        frame_bytes = enc->frame_size * osize * enc->channels;
963

    
964
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
965
            AVPacket pkt;
966
            av_init_packet(&pkt);
967

    
968
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
969

    
970
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
971

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

    
987
            ost->sync_opts += enc->frame_size;
988
        }
989
    } else {
990
        AVPacket pkt;
991
        av_init_packet(&pkt);
992

    
993
        ost->sync_opts += size_out / (osize * enc->channels);
994

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

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

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

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

    
1031
    dec = ist->st->codec;
1032

    
1033
    /* deinterlace : must be done before any resize */
1034
    if (do_deinterlace) {
1035
        int size;
1036

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

    
1043
        picture2 = &picture_tmp;
1044
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1045

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

    
1058
    if (picture != picture2)
1059
        *picture = *picture2;
1060
    *bufp = buf;
1061
}
1062

    
1063
/* we begin to correct av delay at this threshold */
1064
#define AV_DELAY_MAX 0.100
1065

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

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

    
1085
    enc = ost->st->codec;
1086

    
1087
    if (!subtitle_out) {
1088
        subtitle_out = av_malloc(subtitle_out_max_size);
1089
    }
1090

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

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

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

    
1129
static int bit_buffer_size= 1024*256;
1130
static uint8_t *bit_buffer= NULL;
1131

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

    
1143
    enc = ost->st->codec;
1144
    dec = ist->st->codec;
1145

    
1146
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1147

    
1148
    /* by default, we output a single frame */
1149
    nb_frames = 1;
1150

    
1151
    *frame_size = 0;
1152

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

    
1178
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1179
    if (nb_frames <= 0)
1180
        return;
1181

    
1182
    formatted_picture = in_picture;
1183
    final_picture = formatted_picture;
1184
    padding_src = formatted_picture;
1185
    resampling_dst = &ost->pict_tmp;
1186

    
1187
    if (   ost->resample_height != ist->st->codec->height
1188
        || ost->resample_width  != ist->st->codec->width
1189
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1190

    
1191
        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));
1192
        if(!ost->video_resample)
1193
            ffmpeg_exit(1);
1194
    }
1195

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

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

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

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

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

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

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

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

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

    
1307
static double psnr(double d){
1308
    return -10.0*log(d)/log(10.0);
1309
}
1310

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

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

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

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

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

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

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

    
1375

    
1376
    oc = output_files[0];
1377

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

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

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

    
1441
    if (verbose || is_last_report) {
1442
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1443

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

    
1448
        if (nb_frames_dup || nb_frames_drop)
1449
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1450
                  nb_frames_dup, nb_frames_drop);
1451

    
1452
        if (verbose >= 0)
1453
            fprintf(stderr, "%s    \r", buf);
1454

    
1455
        fflush(stderr);
1456
    }
1457

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

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

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

    
1496
    AVPacket avpkt;
1497
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1498

    
1499
    if(ist->next_pts == AV_NOPTS_VALUE)
1500
        ist->next_pts= ist->pts;
1501

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

    
1512
    if(pkt->dts != AV_NOPTS_VALUE)
1513
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1514
    if(pkt->pts != AV_NOPTS_VALUE)
1515
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1516

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

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

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

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

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

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

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

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

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

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

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

    
1718
                        av_init_packet(&opkt);
1719

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

    
1727
                        /* no reencoding needed : output the packet directly */
1728
                        /* force the input stream PTS */
1729

    
1730
                        avcodec_get_frame_defaults(&avframe);
1731
                        ost->st->codec->coded_frame= &avframe;
1732
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1733

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

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

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

    
1753
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1754
                        opkt.flags= pkt->flags;
1755

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

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

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

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

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

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

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

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

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

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

    
1877
    return 0;
1878
 fail_decode:
1879
    return -1;
1880
}
1881

    
1882
static void print_sdp(AVFormatContext **avc, int n)
1883
{
1884
    char sdp[2048];
1885

    
1886
    av_sdp_create(avc, n, sdp, sizeof(sdp));
1887
    printf("SDP:\n%s\n", sdp);
1888
    fflush(stdout);
1889
}
1890

    
1891
static int copy_chapters(int infile, int outfile)
1892
{
1893
    AVFormatContext *is = input_files[infile];
1894
    AVFormatContext *os = output_files[outfile];
1895
    int i;
1896

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

    
1904

    
1905
        if (in_ch->end < ts_off)
1906
            continue;
1907
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1908
            break;
1909

    
1910
        out_ch = av_mallocz(sizeof(AVChapter));
1911
        if (!out_ch)
1912
            return AVERROR(ENOMEM);
1913

    
1914
        out_ch->id        = in_ch->id;
1915
        out_ch->time_base = in_ch->time_base;
1916
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1917
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1918

    
1919
        if (metadata_chapters_autocopy)
1920
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1921

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

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

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

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

    
1977
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1978
    if (!file_table)
1979
        goto fail;
1980

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

    
1991
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1992
    if (!ist_table)
1993
        goto fail;
1994

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

    
2012
            if (rate_emu) {
2013
                ist->start = av_gettime();
2014
            }
2015
        }
2016
    }
2017

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

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

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

    
2057
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2058
    if (!ost_table)
2059
        goto fail;
2060

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

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

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

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

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

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

    
2181
        codec = ost->st->codec;
2182
        icodec = ist->st->codec;
2183

    
2184
        if (metadata_streams_autocopy)
2185
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2186
                             AV_METADATA_DONT_OVERWRITE);
2187

    
2188
        ost->st->disposition = ist->st->disposition;
2189
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2190
        codec->chroma_sample_location = icodec->chroma_sample_location;
2191

    
2192
        if (ost->st->stream_copy) {
2193
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2194

    
2195
            if (extra_size > INT_MAX)
2196
                goto fail;
2197

    
2198
            /* if stream_copy is selected, no need to decode or encode */
2199
            codec->codec_id = icodec->codec_id;
2200
            codec->codec_type = icodec->codec_type;
2201

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

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

    
2299
                    ost->original_height = icodec->height;
2300
                    ost->original_width  = icodec->width;
2301
#endif
2302
                    codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2303
                }
2304
                ost->resample_height = icodec->height;
2305
                ost->resample_width  = icodec->width;
2306
                ost->resample_pix_fmt= icodec->pix_fmt;
2307
                ost->encoding_needed = 1;
2308
                ist->decoding_needed = 1;
2309

    
2310
#if CONFIG_AVFILTER
2311
                if (configure_video_filters(ist, ost)) {
2312
                    fprintf(stderr, "Error opening filters!\n");
2313
                    exit(1);
2314
                }
2315
#endif
2316
                break;
2317
            case AVMEDIA_TYPE_SUBTITLE:
2318
                ost->encoding_needed = 1;
2319
                ist->decoding_needed = 1;
2320
                break;
2321
            default:
2322
                abort();
2323
                break;
2324
            }
2325
            /* two pass mode */
2326
            if (ost->encoding_needed &&
2327
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2328
                char logfilename[1024];
2329
                FILE *f;
2330

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

    
2359
    if (!bit_buffer)
2360
        bit_buffer = av_malloc(bit_buffer_size);
2361
    if (!bit_buffer) {
2362
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2363
                bit_buffer_size);
2364
        ret = AVERROR(ENOMEM);
2365
        goto fail;
2366
    }
2367

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

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

    
2425
    /* init pts */
2426
    for(i=0;i<nb_istreams;i++) {
2427
        AVStream *st;
2428
        ist = ist_table[i];
2429
        st= ist->st;
2430
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2431
        ist->next_pts = AV_NOPTS_VALUE;
2432
        ist->is_start = 1;
2433
    }
2434

    
2435
    /* set meta data information from input file if required */
2436
    for (i=0;i<nb_meta_data_maps;i++) {
2437
        AVFormatContext *files[2];
2438
        AVMetadata      **meta[2];
2439
        int j;
2440

    
2441
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2442
        if ((index) < 0 || (index) >= (nb_elems)) {\
2443
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2444
                     (desc), (index));\
2445
            ret = AVERROR(EINVAL);\
2446
            goto dump_format;\
2447
        }
2448

    
2449
        int out_file_index = meta_data_maps[i][0].file;
2450
        int in_file_index = meta_data_maps[i][1].file;
2451
        if (in_file_index < 0 || out_file_index < 0)
2452
            continue;
2453
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2454
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2455

    
2456
        files[0] = output_files[out_file_index];
2457
        files[1] = input_files[in_file_index];
2458

    
2459
        for (j = 0; j < 2; j++) {
2460
            AVMetaDataMap *map = &meta_data_maps[i][j];
2461

    
2462
            switch (map->type) {
2463
            case 'g':
2464
                meta[j] = &files[j]->metadata;
2465
                break;
2466
            case 's':
2467
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2468
                meta[j] = &files[j]->streams[map->index]->metadata;
2469
                break;
2470
            case 'c':
2471
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2472
                meta[j] = &files[j]->chapters[map->index]->metadata;
2473
                break;
2474
            case 'p':
2475
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2476
                meta[j] = &files[j]->programs[map->index]->metadata;
2477
                break;
2478
            }
2479
        }
2480

    
2481
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2482
    }
2483

    
2484
    /* copy global metadata by default */
2485
    if (metadata_global_autocopy) {
2486

    
2487
        for (i = 0; i < nb_output_files; i++)
2488
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2489
                             AV_METADATA_DONT_OVERWRITE);
2490
    }
2491

    
2492
    /* copy chapters according to chapter maps */
2493
    for (i = 0; i < nb_chapter_maps; i++) {
2494
        int infile  = chapter_maps[i].in_file;
2495
        int outfile = chapter_maps[i].out_file;
2496

    
2497
        if (infile < 0 || outfile < 0)
2498
            continue;
2499
        if (infile >= nb_input_files) {
2500
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2501
            ret = AVERROR(EINVAL);
2502
            goto dump_format;
2503
        }
2504
        if (outfile >= nb_output_files) {
2505
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2506
            ret = AVERROR(EINVAL);
2507
            goto dump_format;
2508
        }
2509
        copy_chapters(infile, outfile);
2510
    }
2511

    
2512
    /* copy chapters from the first input file that has them*/
2513
    if (!nb_chapter_maps)
2514
        for (i = 0; i < nb_input_files; i++) {
2515
            if (!input_files[i]->nb_chapters)
2516
                continue;
2517

    
2518
            for (j = 0; j < nb_output_files; j++)
2519
                if ((ret = copy_chapters(i, j)) < 0)
2520
                    goto dump_format;
2521
            break;
2522
        }
2523

    
2524
    /* open files and write file headers */
2525
    for(i=0;i<nb_output_files;i++) {
2526
        os = output_files[i];
2527
        if (av_write_header(os) < 0) {
2528
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2529
            ret = AVERROR(EINVAL);
2530
            goto dump_format;
2531
        }
2532
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2533
            want_sdp = 0;
2534
        }
2535
    }
2536

    
2537
 dump_format:
2538
    /* dump the file output parameters - cannot be done before in case
2539
       of stream copy */
2540
    for(i=0;i<nb_output_files;i++) {
2541
        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2542
    }
2543

    
2544
    /* dump the stream mapping */
2545
    if (verbose >= 0) {
2546
        fprintf(stderr, "Stream mapping:\n");
2547
        for(i=0;i<nb_ostreams;i++) {
2548
            ost = ost_table[i];
2549
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2550
                    ist_table[ost->source_index]->file_index,
2551
                    ist_table[ost->source_index]->index,
2552
                    ost->file_index,
2553
                    ost->index);
2554
            if (ost->sync_ist != ist_table[ost->source_index])
2555
                fprintf(stderr, " [sync #%d.%d]",
2556
                        ost->sync_ist->file_index,
2557
                        ost->sync_ist->index);
2558
            fprintf(stderr, "\n");
2559
        }
2560
    }
2561

    
2562
    if (ret) {
2563
        fprintf(stderr, "%s\n", error);
2564
        goto fail;
2565
    }
2566

    
2567
    if (want_sdp) {
2568
        print_sdp(output_files, nb_output_files);
2569
    }
2570

    
2571
    if (!using_stdin) {
2572
        if(verbose >= 0)
2573
            fprintf(stderr, "Press [q] to stop encoding\n");
2574
        avio_set_interrupt_cb(decode_interrupt_cb);
2575
    }
2576
    term_init();
2577

    
2578
    timer_start = av_gettime();
2579

    
2580
    for(; received_sigterm == 0;) {
2581
        int file_index, ist_index;
2582
        AVPacket pkt;
2583
        double ipts_min;
2584
        double opts_min;
2585

    
2586
    redo:
2587
        ipts_min= 1e100;
2588
        opts_min= 1e100;
2589
        /* if 'q' pressed, exits */
2590
        if (!using_stdin) {
2591
            if (q_pressed)
2592
                break;
2593
            /* read_key() returns 0 on EOF */
2594
            key = read_key();
2595
            if (key == 'q')
2596
                break;
2597
        }
2598

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

    
2637
        /* finish if limit size exhausted */
2638
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2639
            break;
2640

    
2641
        /* read a frame from it and output it in the fifo */
2642
        is = input_files[file_index];
2643
        ret= av_read_frame(is, &pkt);
2644
        if(ret == AVERROR(EAGAIN)){
2645
            no_packet[file_index]=1;
2646
            no_packet_count++;
2647
            continue;
2648
        }
2649
        if (ret < 0) {
2650
            file_table[file_index].eof_reached = 1;
2651
            if (opt_shortest)
2652
                break;
2653
            else
2654
                continue;
2655
        }
2656

    
2657
        no_packet_count=0;
2658
        memset(no_packet, 0, sizeof(no_packet));
2659

    
2660
        if (do_pkt_dump) {
2661
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2662
                             is->streams[pkt.stream_index]);
2663
        }
2664
        /* the following test is needed in case new streams appear
2665
           dynamically in stream : we ignore them */
2666
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2667
            goto discard_packet;
2668
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2669
        ist = ist_table[ist_index];
2670
        if (ist->discard)
2671
            goto discard_packet;
2672

    
2673
        if (pkt.dts != AV_NOPTS_VALUE)
2674
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2675
        if (pkt.pts != AV_NOPTS_VALUE)
2676
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2677

    
2678
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2679
            && input_files_ts_scale[file_index][pkt.stream_index]){
2680
            if(pkt.pts != AV_NOPTS_VALUE)
2681
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2682
            if(pkt.dts != AV_NOPTS_VALUE)
2683
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2684
        }
2685

    
2686
//        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);
2687
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2688
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2689
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2690
            int64_t delta= pkt_dts - ist->next_pts;
2691
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2692
                input_files_ts_offset[ist->file_index]-= delta;
2693
                if (verbose > 2)
2694
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2695
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2696
                if(pkt.pts != AV_NOPTS_VALUE)
2697
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2698
            }
2699
        }
2700

    
2701
        /* finish if recording time exhausted */
2702
        if (recording_time != INT64_MAX &&
2703
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2704
            ist->is_past_recording_time = 1;
2705
            goto discard_packet;
2706
        }
2707

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

    
2711
            if (verbose >= 0)
2712
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2713
                        ist->file_index, ist->index);
2714
            if (exit_on_error)
2715
                ffmpeg_exit(1);
2716
            av_free_packet(&pkt);
2717
            goto redo;
2718
        }
2719

    
2720
    discard_packet:
2721
        av_free_packet(&pkt);
2722

    
2723
        /* dump report by using the output first video and audio streams */
2724
        print_report(output_files, ost_table, nb_ostreams, 0);
2725
    }
2726

    
2727
    /* at the end of stream, we must flush the decoder buffers */
2728
    for(i=0;i<nb_istreams;i++) {
2729
        ist = ist_table[i];
2730
        if (ist->decoding_needed) {
2731
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2732
        }
2733
    }
2734

    
2735
    term_exit();
2736

    
2737
    /* write the trailer if needed and close file */
2738
    for(i=0;i<nb_output_files;i++) {
2739
        os = output_files[i];
2740
        av_write_trailer(os);
2741
    }
2742

    
2743
    /* dump report by using the first video and audio streams */
2744
    print_report(output_files, ost_table, nb_ostreams, 1);
2745

    
2746
    /* close each encoder */
2747
    for(i=0;i<nb_ostreams;i++) {
2748
        ost = ost_table[i];
2749
        if (ost->encoding_needed) {
2750
            av_freep(&ost->st->codec->stats_in);
2751
            avcodec_close(ost->st->codec);
2752
        }
2753
#if CONFIG_AVFILTER
2754
        avfilter_graph_free(&ost->graph);
2755
#endif
2756
    }
2757

    
2758
    /* close each decoder */
2759
    for(i=0;i<nb_istreams;i++) {
2760
        ist = ist_table[i];
2761
        if (ist->decoding_needed) {
2762
            avcodec_close(ist->st->codec);
2763
        }
2764
    }
2765

    
2766
    /* finished ! */
2767
    ret = 0;
2768

    
2769
 fail:
2770
    av_freep(&bit_buffer);
2771
    av_free(file_table);
2772

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

    
2809
static void opt_format(const char *arg)
2810
{
2811
    last_asked_format = arg;
2812
}
2813

    
2814
static void opt_video_rc_override_string(const char *arg)
2815
{
2816
    video_rc_override_string = arg;
2817
}
2818

    
2819
static int opt_me_threshold(const char *opt, const char *arg)
2820
{
2821
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2822
    return 0;
2823
}
2824

    
2825
static int opt_verbose(const char *opt, const char *arg)
2826
{
2827
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2828
    return 0;
2829
}
2830

    
2831
static int opt_frame_rate(const char *opt, const char *arg)
2832
{
2833
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2834
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2835
        ffmpeg_exit(1);
2836
    }
2837
    return 0;
2838
}
2839

    
2840
static int opt_bitrate(const char *opt, const char *arg)
2841
{
2842
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2843

    
2844
    opt_default(opt, arg);
2845

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

    
2849
    return 0;
2850
}
2851

    
2852
static int opt_frame_crop(const char *opt, const char *arg)
2853
{
2854
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2855
    return AVERROR(EINVAL);
2856
}
2857

    
2858
static void opt_frame_size(const char *arg)
2859
{
2860
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2861
        fprintf(stderr, "Incorrect frame size\n");
2862
        ffmpeg_exit(1);
2863
    }
2864
}
2865

    
2866
static int opt_pad(const char *opt, const char *arg) {
2867
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2868
    return -1;
2869
}
2870

    
2871
static void opt_frame_pix_fmt(const char *arg)
2872
{
2873
    if (strcmp(arg, "list")) {
2874
        frame_pix_fmt = av_get_pix_fmt(arg);
2875
        if (frame_pix_fmt == PIX_FMT_NONE) {
2876
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2877
            ffmpeg_exit(1);
2878
        }
2879
    } else {
2880
        show_pix_fmts();
2881
        ffmpeg_exit(0);
2882
    }
2883
}
2884

    
2885
static void opt_frame_aspect_ratio(const char *arg)
2886
{
2887
    int x = 0, y = 0;
2888
    double ar = 0;
2889
    const char *p;
2890
    char *end;
2891

    
2892
    p = strchr(arg, ':');
2893
    if (p) {
2894
        x = strtol(arg, &end, 10);
2895
        if (end == p)
2896
            y = strtol(end+1, &end, 10);
2897
        if (x > 0 && y > 0)
2898
            ar = (double)x / (double)y;
2899
    } else
2900
        ar = strtod(arg, NULL);
2901

    
2902
    if (!ar) {
2903
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2904
        ffmpeg_exit(1);
2905
    }
2906
    frame_aspect_ratio = ar;
2907
    frame_aspect_ratio_override = 1;
2908
}
2909

    
2910
static int opt_metadata(const char *opt, const char *arg)
2911
{
2912
    char *mid= strchr(arg, '=');
2913

    
2914
    if(!mid){
2915
        fprintf(stderr, "Missing =\n");
2916
        ffmpeg_exit(1);
2917
    }
2918
    *mid++= 0;
2919

    
2920
    av_metadata_set2(&metadata, arg, mid, 0);
2921

    
2922
    return 0;
2923
}
2924

    
2925
static void opt_qscale(const char *arg)
2926
{
2927
    video_qscale = atof(arg);
2928
    if (video_qscale <= 0 ||
2929
        video_qscale > 255) {
2930
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2931
        ffmpeg_exit(1);
2932
    }
2933
}
2934

    
2935
static void opt_top_field_first(const char *arg)
2936
{
2937
    top_field_first= atoi(arg);
2938
}
2939

    
2940
static int opt_thread_count(const char *opt, const char *arg)
2941
{
2942
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2943
#if !HAVE_THREADS
2944
    if (verbose >= 0)
2945
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2946
#endif
2947
    return 0;
2948
}
2949

    
2950
static void opt_audio_sample_fmt(const char *arg)
2951
{
2952
    if (strcmp(arg, "list")) {
2953
        audio_sample_fmt = av_get_sample_fmt(arg);
2954
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2955
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2956
            ffmpeg_exit(1);
2957
        }
2958
    } else {
2959
        int i;
2960
        char fmt_str[128];
2961
        for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2962
            printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2963
        ffmpeg_exit(0);
2964
    }
2965
}
2966

    
2967
static int opt_audio_rate(const char *opt, const char *arg)
2968
{
2969
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2970
    return 0;
2971
}
2972

    
2973
static int opt_audio_channels(const char *opt, const char *arg)
2974
{
2975
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2976
    return 0;
2977
}
2978

    
2979
static void opt_video_channel(const char *arg)
2980
{
2981
    video_channel = strtol(arg, NULL, 0);
2982
}
2983

    
2984
static void opt_video_standard(const char *arg)
2985
{
2986
    video_standard = av_strdup(arg);
2987
}
2988

    
2989
static void opt_codec(int *pstream_copy, char **pcodec_name,
2990
                      int codec_type, const char *arg)
2991
{
2992
    av_freep(pcodec_name);
2993
    if (!strcmp(arg, "copy")) {
2994
        *pstream_copy = 1;
2995
    } else {
2996
        *pcodec_name = av_strdup(arg);
2997
    }
2998
}
2999

    
3000
static void opt_audio_codec(const char *arg)
3001
{
3002
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
3003
}
3004

    
3005
static void opt_video_codec(const char *arg)
3006
{
3007
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
3008
}
3009

    
3010
static void opt_subtitle_codec(const char *arg)
3011
{
3012
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3013
}
3014

    
3015
static int opt_codec_tag(const char *opt, const char *arg)
3016
{
3017
    char *tail;
3018
    uint32_t *codec_tag;
3019

    
3020
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3021
                !strcmp(opt, "vtag") ? &video_codec_tag :
3022
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3023
    if (!codec_tag)
3024
        return -1;
3025

    
3026
    *codec_tag = strtol(arg, &tail, 0);
3027
    if (!tail || *tail)
3028
        *codec_tag = AV_RL32(arg);
3029

    
3030
    return 0;
3031
}
3032

    
3033
static void opt_map(const char *arg)
3034
{
3035
    AVStreamMap *m;
3036
    char *p;
3037

    
3038
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3039
    m = &stream_maps[nb_stream_maps-1];
3040

    
3041
    m->file_index = strtol(arg, &p, 0);
3042
    if (*p)
3043
        p++;
3044

    
3045
    m->stream_index = strtol(p, &p, 0);
3046
    if (*p) {
3047
        p++;
3048
        m->sync_file_index = strtol(p, &p, 0);
3049
        if (*p)
3050
            p++;
3051
        m->sync_stream_index = strtol(p, &p, 0);
3052
    } else {
3053
        m->sync_file_index = m->file_index;
3054
        m->sync_stream_index = m->stream_index;
3055
    }
3056
}
3057

    
3058
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3059
{
3060
    *endptr = arg;
3061
    if (*arg == ',') {
3062
        *type = *(++arg);
3063
        switch (*arg) {
3064
        case 'g':
3065
            break;
3066
        case 's':
3067
        case 'c':
3068
        case 'p':
3069
            *index = strtol(++arg, endptr, 0);
3070
            break;
3071
        default:
3072
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3073
            ffmpeg_exit(1);
3074
        }
3075
    } else
3076
        *type = 'g';
3077
}
3078

    
3079
static void opt_map_metadata(const char *arg)
3080
{
3081
    AVMetaDataMap *m, *m1;
3082
    char *p;
3083

    
3084
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3085
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3086

    
3087
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3088
    m->file = strtol(arg, &p, 0);
3089
    parse_meta_type(p, &m->type, &m->index, &p);
3090
    if (*p)
3091
        p++;
3092

    
3093
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3094
    m1->file = strtol(p, &p, 0);
3095
    parse_meta_type(p, &m1->type, &m1->index, &p);
3096

    
3097
    if (m->type == 'g' || m1->type == 'g')
3098
        metadata_global_autocopy = 0;
3099
    if (m->type == 's' || m1->type == 's')
3100
        metadata_streams_autocopy = 0;
3101
    if (m->type == 'c' || m1->type == 'c')
3102
        metadata_chapters_autocopy = 0;
3103
}
3104

    
3105
static void opt_map_meta_data(const char *arg)
3106
{
3107
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3108
                    "Use -map_metadata instead.\n");
3109
    opt_map_metadata(arg);
3110
}
3111

    
3112
static void opt_map_chapters(const char *arg)
3113
{
3114
    AVChapterMap *c;
3115
    char *p;
3116

    
3117
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3118
                              nb_chapter_maps + 1);
3119
    c = &chapter_maps[nb_chapter_maps - 1];
3120
    c->out_file = strtol(arg, &p, 0);
3121
    if (*p)
3122
        p++;
3123

    
3124
    c->in_file = strtol(p, &p, 0);
3125
}
3126

    
3127
static void opt_input_ts_scale(const char *arg)
3128
{
3129
    unsigned int stream;
3130
    double scale;
3131
    char *p;
3132

    
3133
    stream = strtol(arg, &p, 0);
3134
    if (*p)
3135
        p++;
3136
    scale= strtod(p, &p);
3137

    
3138
    if(stream >= MAX_STREAMS)
3139
        ffmpeg_exit(1);
3140

    
3141
    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);
3142
    input_files_ts_scale[nb_input_files][stream]= scale;
3143
}
3144

    
3145
static int opt_recording_time(const char *opt, const char *arg)
3146
{
3147
    recording_time = parse_time_or_die(opt, arg, 1);
3148
    return 0;
3149
}
3150

    
3151
static int opt_start_time(const char *opt, const char *arg)
3152
{
3153
    start_time = parse_time_or_die(opt, arg, 1);
3154
    return 0;
3155
}
3156

    
3157
static int opt_recording_timestamp(const char *opt, const char *arg)
3158
{
3159
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3160
    return 0;
3161
}
3162

    
3163
static int opt_input_ts_offset(const char *opt, const char *arg)
3164
{
3165
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3166
    return 0;
3167
}
3168

    
3169
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3170
{
3171
    const char *codec_string = encoder ? "encoder" : "decoder";
3172
    AVCodec *codec;
3173

    
3174
    if(!name)
3175
        return CODEC_ID_NONE;
3176
    codec = encoder ?
3177
        avcodec_find_encoder_by_name(name) :
3178
        avcodec_find_decoder_by_name(name);
3179
    if(!codec) {
3180
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3181
        ffmpeg_exit(1);
3182
    }
3183
    if(codec->type != type) {
3184
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3185
        ffmpeg_exit(1);
3186
    }
3187
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3188
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3189
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3190
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3191
                codec_string, codec->name);
3192
        codec = encoder ?
3193
            avcodec_find_encoder(codec->id) :
3194
            avcodec_find_decoder(codec->id);
3195
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3196
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3197
                    codec_string, codec->name);
3198
        ffmpeg_exit(1);
3199
    }
3200
    return codec->id;
3201
}
3202

    
3203
static void opt_input_file(const char *filename)
3204
{
3205
    AVFormatContext *ic;
3206
    AVFormatParameters params, *ap = &params;
3207
    AVInputFormat *file_iformat = NULL;
3208
    int err, i, ret, rfps, rfps_base;
3209
    int64_t timestamp;
3210

    
3211
    if (last_asked_format) {
3212
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3213
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3214
            ffmpeg_exit(1);
3215
        }
3216
        last_asked_format = NULL;
3217
    }
3218

    
3219
    if (!strcmp(filename, "-"))
3220
        filename = "pipe:";
3221

    
3222
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3223
                    !strcmp(filename, "/dev/stdin");
3224

    
3225
    /* get default parameters from command line */
3226
    ic = avformat_alloc_context();
3227
    if (!ic) {
3228
        print_error(filename, AVERROR(ENOMEM));
3229
        ffmpeg_exit(1);
3230
    }
3231

    
3232
    memset(ap, 0, sizeof(*ap));
3233
    ap->prealloced_context = 1;
3234
    ap->sample_rate = audio_sample_rate;
3235
    ap->channels = audio_channels;
3236
    ap->time_base.den = frame_rate.num;
3237
    ap->time_base.num = frame_rate.den;
3238
    ap->width = frame_width;
3239
    ap->height = frame_height;
3240
    ap->pix_fmt = frame_pix_fmt;
3241
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3242
    ap->channel = video_channel;
3243
    ap->standard = video_standard;
3244

    
3245
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3246

    
3247
    ic->video_codec_id   =
3248
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3249
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3250
    ic->audio_codec_id   =
3251
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3252
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3253
    ic->subtitle_codec_id=
3254
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3255
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3256
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3257

    
3258
    /* open the input file with generic libav function */
3259
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3260
    if (err < 0) {
3261
        print_error(filename, err);
3262
        ffmpeg_exit(1);
3263
    }
3264
    if(opt_programid) {
3265
        int i, j;
3266
        int found=0;
3267
        for(i=0; i<ic->nb_streams; i++){
3268
            ic->streams[i]->discard= AVDISCARD_ALL;
3269
        }
3270
        for(i=0; i<ic->nb_programs; i++){
3271
            AVProgram *p= ic->programs[i];
3272
            if(p->id != opt_programid){
3273
                p->discard = AVDISCARD_ALL;
3274
            }else{
3275
                found=1;
3276
                for(j=0; j<p->nb_stream_indexes; j++){
3277
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3278
                }
3279
            }
3280
        }
3281
        if(!found){
3282
            fprintf(stderr, "Specified program id not found\n");
3283
            ffmpeg_exit(1);
3284
        }
3285
        opt_programid=0;
3286
    }
3287

    
3288
    ic->loop_input = loop_input;
3289

    
3290
    /* If not enough info to get the stream parameters, we decode the
3291
       first frames to get it. (used in mpeg case for example) */
3292
    ret = av_find_stream_info(ic);
3293
    if (ret < 0 && verbose >= 0) {
3294
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3295
        av_close_input_file(ic);
3296
        ffmpeg_exit(1);
3297
    }
3298

    
3299
    timestamp = start_time;
3300
    /* add the stream start time */
3301
    if (ic->start_time != AV_NOPTS_VALUE)
3302
        timestamp += ic->start_time;
3303

    
3304
    /* if seeking requested, we execute it */
3305
    if (start_time != 0) {
3306
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3307
        if (ret < 0) {
3308
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3309
                    filename, (double)timestamp / AV_TIME_BASE);
3310
        }
3311
        /* reset seek info */
3312
        start_time = 0;
3313
    }
3314

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

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

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

    
3368
                    (float)rfps / rfps_base, rfps, rfps_base);
3369
            }
3370
            /* update the current frame rate to match the stream frame rate */
3371
            frame_rate.num = rfps;
3372
            frame_rate.den = rfps_base;
3373

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

    
3394
    input_files[nb_input_files] = ic;
3395
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3396
    /* dump the file content */
3397
    if (verbose >= 0)
3398
        av_dump_format(ic, nb_input_files, filename, 0);
3399

    
3400
    nb_input_files++;
3401

    
3402
    video_channel = 0;
3403

    
3404
    av_freep(&video_codec_name);
3405
    av_freep(&audio_codec_name);
3406
    av_freep(&subtitle_codec_name);
3407
}
3408

    
3409
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3410
                                         int *has_subtitle_ptr)
3411
{
3412
    int has_video, has_audio, has_subtitle, i, j;
3413
    AVFormatContext *ic;
3414

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

    
3446
static void new_video_stream(AVFormatContext *oc, int file_idx)
3447
{
3448
    AVStream *st;
3449
    AVOutputStream *ost;
3450
    AVCodecContext *video_enc;
3451
    enum CodecID codec_id = CODEC_ID_NONE;
3452
    AVCodec *codec= NULL;
3453
    int i;
3454

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

    
3462
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3463
    if(!video_stream_copy){
3464
        if (video_codec_name) {
3465
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3466
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3467
            codec = avcodec_find_encoder_by_name(video_codec_name);
3468
            output_codecs[nb_output_codecs-1] = codec;
3469
        } else {
3470
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3471
            codec = avcodec_find_encoder(codec_id);
3472
        }
3473
#if CONFIG_AVFILTER
3474
        if(frame_aspect_ratio_override){
3475
            i = vfilters ? strlen(vfilters) : 0;
3476
            vfilters = av_realloc(vfilters, i+100);
3477
            snprintf(vfilters+i, 100, "%csetdar=%f\n", i?',':' ', frame_aspect_ratio);
3478
            frame_aspect_ratio=0;
3479
            frame_aspect_ratio_override=0;
3480
        }
3481

    
3482
        ost->avfilter= vfilters;
3483
        vfilters= NULL;
3484
#endif
3485
    }
3486

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

    
3491
    st->codec->thread_count= thread_count;
3492

    
3493
    video_enc = st->codec;
3494

    
3495
    if(video_codec_tag)
3496
        video_enc->codec_tag= video_codec_tag;
3497

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

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

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

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

    
3526
        video_enc->width = frame_width;
3527
        video_enc->height = frame_height;
3528
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3529
        video_enc->pix_fmt = frame_pix_fmt;
3530
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3531
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3532

    
3533
        choose_pixel_fmt(st, codec);
3534

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

    
3543
        if(intra_matrix)
3544
            video_enc->intra_matrix = intra_matrix;
3545
        if(inter_matrix)
3546
            video_enc->inter_matrix = inter_matrix;
3547

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

    
3578
        if (do_psnr)
3579
            video_enc->flags|= CODEC_FLAG_PSNR;
3580

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

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

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

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

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

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

    
3634
    avcodec_get_context_defaults3(st->codec, codec);
3635

    
3636
    ost->bitstream_filters = audio_bitstream_filters;
3637
    audio_bitstream_filters= NULL;
3638

    
3639
    st->codec->thread_count= thread_count;
3640

    
3641
    audio_enc = st->codec;
3642
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3643

    
3644
    if(audio_codec_tag)
3645
        audio_enc->codec_tag= audio_codec_tag;
3646

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

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

    
3678
    /* reset some key parameters */
3679
    audio_disable = 0;
3680
    av_freep(&audio_codec_name);
3681
    audio_stream_copy = 0;
3682
}
3683

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

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

    
3712
    ost->bitstream_filters = subtitle_bitstream_filters;
3713
    subtitle_bitstream_filters= NULL;
3714

    
3715
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3716

    
3717
    if(subtitle_codec_tag)
3718
        subtitle_enc->codec_tag= subtitle_codec_tag;
3719

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

    
3731
    if (subtitle_language) {
3732
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3733
        av_freep(&subtitle_language);
3734
    }
3735

    
3736
    subtitle_disable = 0;
3737
    av_freep(&subtitle_codec_name);
3738
    subtitle_stream_copy = 0;
3739
}
3740

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

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

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

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

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

    
3789
    if (!strcmp(filename, "-"))
3790
        filename = "pipe:";
3791

    
3792
    oc = avformat_alloc_context();
3793
    if (!oc) {
3794
        print_error(filename, AVERROR(ENOMEM));
3795
        ffmpeg_exit(1);
3796
    }
3797

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

    
3814
    oc->oformat = file_oformat;
3815
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3816

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

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

    
3844
        /* manual disable */
3845
        if (audio_disable)    use_audio    = 0;
3846
        if (video_disable)    use_video    = 0;
3847
        if (subtitle_disable) use_subtitle = 0;
3848

    
3849
        if (use_video)    new_video_stream(oc, nb_output_files);
3850
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3851
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3852

    
3853
        oc->timestamp = recording_timestamp;
3854

    
3855
        av_metadata_copy(&oc->metadata, metadata, 0);
3856
        av_metadata_free(&metadata);
3857
    }
3858

    
3859
    output_files[nb_output_files++] = oc;
3860

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

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

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

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

    
3905
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3906
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3907
    oc->loop_output = loop_output;
3908

    
3909
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3910

    
3911
    av_freep(&forced_key_frames);
3912
}
3913

    
3914
/* same option as mencoder */
3915
static void opt_pass(const char *pass_str)
3916
{
3917
    int pass;
3918
    pass = atoi(pass_str);
3919
    if (pass != 1 && pass != 2) {
3920
        fprintf(stderr, "pass number can be only 1 or 2\n");
3921
        ffmpeg_exit(1);
3922
    }
3923
    do_pass = pass;
3924
}
3925

    
3926
static int64_t getutime(void)
3927
{
3928
#if HAVE_GETRUSAGE
3929
    struct rusage rusage;
3930

    
3931
    getrusage(RUSAGE_SELF, &rusage);
3932
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3933
#elif HAVE_GETPROCESSTIMES
3934
    HANDLE proc;
3935
    FILETIME c, e, k, u;
3936
    proc = GetCurrentProcess();
3937
    GetProcessTimes(proc, &c, &e, &k, &u);
3938
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3939
#else
3940
    return av_gettime();
3941
#endif
3942
}
3943

    
3944
static int64_t getmaxrss(void)
3945
{
3946
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3947
    struct rusage rusage;
3948
    getrusage(RUSAGE_SELF, &rusage);
3949
    return (int64_t)rusage.ru_maxrss * 1024;
3950
#elif HAVE_GETPROCESSMEMORYINFO
3951
    HANDLE proc;
3952
    PROCESS_MEMORY_COUNTERS memcounters;
3953
    proc = GetCurrentProcess();
3954
    memcounters.cb = sizeof(memcounters);
3955
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3956
    return memcounters.PeakPagefileUsage;
3957
#else
3958
    return 0;
3959
#endif
3960
}
3961

    
3962
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3963
{
3964
    int i;
3965
    const char *p = str;
3966
    for(i = 0;; i++) {
3967
        dest[i] = atoi(p);
3968
        if(i == 63)
3969
            break;
3970
        p = strchr(p, ',');
3971
        if(!p) {
3972
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3973
            ffmpeg_exit(1);
3974
        }
3975
        p++;
3976
    }
3977
}
3978

    
3979
static void opt_inter_matrix(const char *arg)
3980
{
3981
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3982
    parse_matrix_coeffs(inter_matrix, arg);
3983
}
3984

    
3985
static void opt_intra_matrix(const char *arg)
3986
{
3987
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3988
    parse_matrix_coeffs(intra_matrix, arg);
3989
}
3990

    
3991
static void show_usage(void)
3992
{
3993
    printf("Hyper fast Audio and Video encoder\n");
3994
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3995
    printf("\n");
3996
}
3997

    
3998
static void show_help(void)
3999
{
4000
    AVCodec *c;
4001
    AVOutputFormat *oformat = NULL;
4002

    
4003
    av_log_set_callback(log_callback_help);
4004
    show_usage();
4005
    show_help_options(options, "Main options:\n",
4006
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4007
    show_help_options(options, "\nAdvanced options:\n",
4008
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4009
                      OPT_EXPERT);
4010
    show_help_options(options, "\nVideo options:\n",
4011
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4012
                      OPT_VIDEO);
4013
    show_help_options(options, "\nAdvanced Video options:\n",
4014
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4015
                      OPT_VIDEO | OPT_EXPERT);
4016
    show_help_options(options, "\nAudio options:\n",
4017
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4018
                      OPT_AUDIO);
4019
    show_help_options(options, "\nAdvanced Audio options:\n",
4020
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4021
                      OPT_AUDIO | OPT_EXPERT);
4022
    show_help_options(options, "\nSubtitle options:\n",
4023
                      OPT_SUBTITLE | OPT_GRAB,
4024
                      OPT_SUBTITLE);
4025
    show_help_options(options, "\nAudio/Video grab options:\n",
4026
                      OPT_GRAB,
4027
                      OPT_GRAB);
4028
    printf("\n");
4029
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4030
    printf("\n");
4031

    
4032
    /* individual codec options */
4033
    c = NULL;
4034
    while ((c = av_codec_next(c))) {
4035
        if (c->priv_class) {
4036
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4037
            printf("\n");
4038
        }
4039
    }
4040

    
4041
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4042
    printf("\n");
4043

    
4044
    /* individual muxer options */
4045
    while ((oformat = av_oformat_next(oformat))) {
4046
        if (oformat->priv_class) {
4047
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4048
            printf("\n");
4049
        }
4050
    }
4051

    
4052
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4053
}
4054

    
4055
static void opt_target(const char *arg)
4056
{
4057
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4058
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4059

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

    
4104
    if(norm == UNKNOWN) {
4105
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4106
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4107
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4108
        ffmpeg_exit(1);
4109
    }
4110

    
4111
    if(!strcmp(arg, "vcd")) {
4112

    
4113
        opt_video_codec("mpeg1video");
4114
        opt_audio_codec("mp2");
4115
        opt_format("vcd");
4116

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

    
4121
        opt_default("b", "1150000");
4122
        opt_default("maxrate", "1150000");
4123
        opt_default("minrate", "1150000");
4124
        opt_default("bufsize", "327680"); // 40*1024*8;
4125

    
4126
        opt_default("ab", "224000");
4127
        audio_sample_rate = 44100;
4128
        audio_channels = 2;
4129

    
4130
        opt_default("packetsize", "2324");
4131
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4132

    
4133
        /* We have to offset the PTS, so that it is consistent with the SCR.
4134
           SCR starts at 36000, but the first two packs contain only padding
4135
           and the first pack from the other stream, respectively, may also have
4136
           been written before.
4137
           So the real data starts at SCR 36000+3*1200. */
4138
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4139
    } else if(!strcmp(arg, "svcd")) {
4140

    
4141
        opt_video_codec("mpeg2video");
4142
        opt_audio_codec("mp2");
4143
        opt_format("svcd");
4144

    
4145
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4146
        opt_frame_rate(NULL, frame_rates[norm]);
4147
        opt_default("g", norm == PAL ? "15" : "18");
4148

    
4149
        opt_default("b", "2040000");
4150
        opt_default("maxrate", "2516000");
4151
        opt_default("minrate", "0"); //1145000;
4152
        opt_default("bufsize", "1835008"); //224*1024*8;
4153
        opt_default("flags", "+scan_offset");
4154

    
4155

    
4156
        opt_default("ab", "224000");
4157
        audio_sample_rate = 44100;
4158

    
4159
        opt_default("packetsize", "2324");
4160

    
4161
    } else if(!strcmp(arg, "dvd")) {
4162

    
4163
        opt_video_codec("mpeg2video");
4164
        opt_audio_codec("ac3");
4165
        opt_format("dvd");
4166

    
4167
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4168
        opt_frame_rate(NULL, frame_rates[norm]);
4169
        opt_default("g", norm == PAL ? "15" : "18");
4170

    
4171
        opt_default("b", "6000000");
4172
        opt_default("maxrate", "9000000");
4173
        opt_default("minrate", "0"); //1500000;
4174
        opt_default("bufsize", "1835008"); //224*1024*8;
4175

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

    
4179
        opt_default("ab", "448000");
4180
        audio_sample_rate = 48000;
4181

    
4182
    } else if(!strncmp(arg, "dv", 2)) {
4183

    
4184
        opt_format("dv");
4185

    
4186
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4187
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4188
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4189
        opt_frame_rate(NULL, frame_rates[norm]);
4190

    
4191
        audio_sample_rate = 48000;
4192
        audio_channels = 2;
4193

    
4194
    } else {
4195
        fprintf(stderr, "Unknown target: %s\n", arg);
4196
        ffmpeg_exit(1);
4197
    }
4198
}
4199

    
4200
static void opt_vstats_file (const char *arg)
4201
{
4202
    av_free (vstats_filename);
4203
    vstats_filename=av_strdup (arg);
4204
}
4205

    
4206
static void opt_vstats (void)
4207
{
4208
    char filename[40];
4209
    time_t today2 = time(NULL);
4210
    struct tm *today = localtime(&today2);
4211

    
4212
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4213
             today->tm_sec);
4214
    opt_vstats_file(filename);
4215
}
4216

    
4217
static int opt_bsf(const char *opt, const char *arg)
4218
{
4219
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4220
    AVBitStreamFilterContext **bsfp;
4221

    
4222
    if(!bsfc){
4223
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4224
        ffmpeg_exit(1);
4225
    }
4226

    
4227
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4228
          *opt == 'a' ? &audio_bitstream_filters :
4229
                        &subtitle_bitstream_filters;
4230
    while(*bsfp)
4231
        bsfp= &(*bsfp)->next;
4232

    
4233
    *bsfp= bsfc;
4234

    
4235
    return 0;
4236
}
4237

    
4238
static int opt_preset(const char *opt, const char *arg)
4239
{
4240
    FILE *f=NULL;
4241
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4242
    char *codec_name = *opt == 'v' ? video_codec_name :
4243
                       *opt == 'a' ? audio_codec_name :
4244
                                     subtitle_codec_name;
4245

    
4246
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4247
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4248
        ffmpeg_exit(1);
4249
    }
4250

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

    
4272
    fclose(f);
4273

    
4274
    return 0;
4275
}
4276

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

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

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

    
4385
    /* subtitle options */
4386
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4387
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4388
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4389
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4390
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4391

    
4392
    /* grab options */
4393
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4394
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4395
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4396

    
4397
    /* muxer options */
4398
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4399
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4400

    
4401
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4402
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4403
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4404

    
4405
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4406
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4407
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4408
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4409

    
4410
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4411
    { NULL, },
4412
};
4413

    
4414
int main(int argc, char **argv)
4415
{
4416
    int64_t ti;
4417

    
4418
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4419

    
4420
    avcodec_register_all();
4421
#if CONFIG_AVDEVICE
4422
    avdevice_register_all();
4423
#endif
4424
#if CONFIG_AVFILTER
4425
    avfilter_register_all();
4426
#endif
4427
    av_register_all();
4428

    
4429
#if HAVE_ISATTY
4430
    if(isatty(STDIN_FILENO))
4431
        avio_set_interrupt_cb(decode_interrupt_cb);
4432
#endif
4433

    
4434
    init_opts();
4435

    
4436
    show_banner();
4437

    
4438
    /* parse options */
4439
    parse_options(argc, argv, options, opt_output_file);
4440

    
4441
    if(nb_output_files <= 0 && nb_input_files == 0) {
4442
        show_usage();
4443
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4444
        ffmpeg_exit(1);
4445
    }
4446

    
4447
    /* file converter / grab */
4448
    if (nb_output_files <= 0) {
4449
        fprintf(stderr, "At least one output file must be specified\n");
4450
        ffmpeg_exit(1);
4451
    }
4452

    
4453
    if (nb_input_files == 0) {
4454
        fprintf(stderr, "At least one input file must be specified\n");
4455
        ffmpeg_exit(1);
4456
    }
4457

    
4458
    ti = getutime();
4459
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4460
                  stream_maps, nb_stream_maps) < 0)
4461
        ffmpeg_exit(1);
4462
    ti = getutime() - ti;
4463
    if (do_benchmark) {
4464
        int maxrss = getmaxrss() / 1024;
4465
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4466
    }
4467

    
4468
    return ffmpeg_exit(0);
4469
}