Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 0f230c53

History | View | Annotate | Download (163 KB)

1
/*
2
 * FFmpeg main
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

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

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

    
50
#include "libavformat/ffm.h" // not public API
51

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

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

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

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

    
84
#include "cmdutils.h"
85

    
86
#include "libavutil/avassert.h"
87

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

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

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

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

    
113
static const OptionDef options[];
114

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

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

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

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

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

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

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

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

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

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

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

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

    
228
static int rate_emu = 0;
229

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

    
233
static int audio_volume = 256;
234

    
235
static int exit_on_error = 0;
236
static int using_stdin = 0;
237
static int verbose = 1;
238
static int daemon  = 0;
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
    float frame_aspect_ratio;
291

    
292
    /* forced key frames */
293
    int64_t *forced_kf_pts;
294
    int forced_kf_count;
295
    int forced_kf_index;
296

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

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

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

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

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

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

    
348
#if HAVE_TERMIOS_H
349

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

    
354
#if CONFIG_AVFILTER
355

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

    
367
    ost->graph = avfilter_graph_alloc();
368

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

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

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

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

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

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

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

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

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

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

    
429
    codec->width  = ost->output_video_filter->inputs[0]->w;
430
    codec->height = ost->output_video_filter->inputs[0]->h;
431
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
432
        ost->frame_aspect_ratio ? // overriden by the -aspect cli option
433
        av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
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
    if(!daemon)
445
        tcsetattr (0, TCSANOW, &oldtty);
446
#endif
447
}
448

    
449
static volatile int received_sigterm = 0;
450

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

    
459
static void term_init(void)
460
{
461
#if HAVE_TERMIOS_H
462
    if(!daemon){
463
    struct termios tty;
464

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

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

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

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

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

    
499
    if(daemon)
500
        return -1;
501

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

    
512
        return n;
513
    }
514
#elif HAVE_KBHIT
515
    if(kbhit())
516
        return(getch());
517
#endif
518
    return -1;
519
}
520

    
521
static int decode_interrupt_cb(void)
522
{
523
    q_pressed += read_key() == 'q';
524
    return q_pressed > 1;
525
}
526

    
527
static int ffmpeg_exit(int ret)
528
{
529
    int i;
530

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

    
544
    av_free(intra_matrix);
545
    av_free(inter_matrix);
546

    
547
    if (vstats_file)
548
        fclose(vstats_file);
549
    av_free(vstats_filename);
550

    
551
    av_free(streamid_map);
552
    av_free(input_codecs);
553
    av_free(output_codecs);
554
    av_free(stream_maps);
555
    av_free(meta_data_maps);
556

    
557
    av_free(video_codec_name);
558
    av_free(audio_codec_name);
559
    av_free(subtitle_codec_name);
560

    
561
    av_free(video_standard);
562

    
563
    uninit_opts();
564
    av_free(audio_buf);
565
    av_free(audio_out);
566
    allocated_audio_buf_size= allocated_audio_out_size= 0;
567
    av_free(samples);
568

    
569
#if CONFIG_AVFILTER
570
    avfilter_uninit();
571
#endif
572

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

    
580
    exit(ret); /* not all OS-es handle main() return value */
581
    return ret;
582
}
583

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

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

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

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

    
670
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
671
{
672
    int idx = oc->nb_streams - 1;
673
    AVOutputStream *ost;
674

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

    
691
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
692
{
693
    int i, err;
694
    AVFormatContext *ic;
695
    int nopts = 0;
696

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

    
706
        s->nb_streams++;
707

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

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

    
732
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
733
            nopts = 1;
734

    
735
        new_output_stream(s, nb_output_files);
736
    }
737

    
738
    if (!nopts)
739
        s->timestamp = av_gettime();
740

    
741
    av_close_input_file(ic);
742
    return 0;
743
}
744

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

    
752
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
753
    int ret;
754

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

    
774
        bsfc= bsfc->next;
775
    }
776

    
777
    ret= av_interleaved_write_frame(s, pkt);
778
    if(ret < 0){
779
        print_error("av_interleaved_write_frame()", ret);
780
        ffmpeg_exit(1);
781
    }
782
}
783

    
784
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
785

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

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

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

    
809
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
810
    if(coded_bps > 8*osize)
811
        audio_out_size= audio_out_size * coded_bps / (8*osize);
812
    audio_out_size += FF_MIN_BUFFER_SIZE;
813

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

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

    
826
    if (enc->channels != dec->channels)
827
        ost->audio_resample = 1;
828

    
829
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
830
                       ost->resample_channels    != dec->channels   ||
831
                       ost->resample_sample_rate != dec->sample_rate;
832

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

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

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

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

    
906
                    if(byte_delta > allocated_for_size - size){
907
                        allocated_for_size= byte_delta + (int64_t)size;
908
                        goto need_realloc;
909
                    }
910
                    ist->is_start=0;
911

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

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

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

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

    
968
        frame_bytes = enc->frame_size * osize * enc->channels;
969

    
970
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
971
            AVPacket pkt;
972
            av_init_packet(&pkt);
973

    
974
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
975

    
976
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
977

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

    
993
            ost->sync_opts += enc->frame_size;
994
        }
995
    } else {
996
        AVPacket pkt;
997
        av_init_packet(&pkt);
998

    
999
        ost->sync_opts += size_out / (osize * enc->channels);
1000

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

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

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

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

    
1037
    dec = ist->st->codec;
1038

    
1039
    /* deinterlace : must be done before any resize */
1040
    if (do_deinterlace) {
1041
        int size;
1042

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

    
1049
        picture2 = &picture_tmp;
1050
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1051

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

    
1064
    if (picture != picture2)
1065
        *picture = *picture2;
1066
    *bufp = buf;
1067
}
1068

    
1069
/* we begin to correct av delay at this threshold */
1070
#define AV_DELAY_MAX 0.100
1071

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

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

    
1091
    enc = ost->st->codec;
1092

    
1093
    if (!subtitle_out) {
1094
        subtitle_out = av_malloc(subtitle_out_max_size);
1095
    }
1096

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

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

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

    
1135
static int bit_buffer_size= 1024*256;
1136
static uint8_t *bit_buffer= NULL;
1137

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

    
1149
    enc = ost->st->codec;
1150
    dec = ist->st->codec;
1151

    
1152
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1153

    
1154
    /* by default, we output a single frame */
1155
    nb_frames = 1;
1156

    
1157
    *frame_size = 0;
1158

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

    
1184
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1185
    if (nb_frames <= 0)
1186
        return;
1187

    
1188
    formatted_picture = in_picture;
1189
    final_picture = formatted_picture;
1190
    resampling_dst = &ost->pict_tmp;
1191

    
1192
    resample_changed = ost->resample_width   != dec->width  ||
1193
                       ost->resample_height  != dec->height ||
1194
                       ost->resample_pix_fmt != dec->pix_fmt;
1195

    
1196
    if (resample_changed) {
1197
        av_log(NULL, AV_LOG_INFO,
1198
               "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1199
               ist->file_index, ist->index,
1200
               ost->resample_width, ost->resample_height, avcodec_get_pix_fmt_name(ost->resample_pix_fmt),
1201
               dec->width         , dec->height         , avcodec_get_pix_fmt_name(dec->pix_fmt));
1202
        if(!ost->video_resample)
1203
            ffmpeg_exit(1);
1204
    }
1205

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

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

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

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

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

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

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

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

    
1313
static double psnr(double d){
1314
    return -10.0*log(d)/log(10.0);
1315
}
1316

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

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

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

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

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

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

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

    
1381

    
1382
    oc = output_files[0];
1383

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

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

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

    
1447
    if (verbose > 0 || is_last_report) {
1448
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1449

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

    
1454
        if (nb_frames_dup || nb_frames_drop)
1455
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1456
                  nb_frames_dup, nb_frames_drop);
1457

    
1458
        if (verbose >= 0)
1459
            fprintf(stderr, "%s    \r", buf);
1460

    
1461
        fflush(stderr);
1462
    }
1463

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

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

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

    
1502
    AVPacket avpkt;
1503
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1504

    
1505
    if(ist->next_pts == AV_NOPTS_VALUE)
1506
        ist->next_pts= ist->pts;
1507

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

    
1518
    if(pkt->dts != AV_NOPTS_VALUE)
1519
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1520
    if(pkt->pts != AV_NOPTS_VALUE)
1521
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1522

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

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

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

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

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

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

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

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

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

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

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

    
1724
                        av_init_packet(&opkt);
1725

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

    
1733
                        /* no reencoding needed : output the packet directly */
1734
                        /* force the input stream PTS */
1735

    
1736
                        avcodec_get_frame_defaults(&avframe);
1737
                        ost->st->codec->coded_frame= &avframe;
1738
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1739

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

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

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

    
1759
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1760
                        opkt.flags= pkt->flags;
1761

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

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

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

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

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

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

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

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

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

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

    
1883
    return 0;
1884
 fail_decode:
1885
    return -1;
1886
}
1887

    
1888
static void print_sdp(AVFormatContext **avc, int n)
1889
{
1890
    char sdp[2048];
1891

    
1892
    av_sdp_create(avc, n, sdp, sizeof(sdp));
1893
    printf("SDP:\n%s\n", sdp);
1894
    fflush(stdout);
1895
}
1896

    
1897
static int copy_chapters(int infile, int outfile)
1898
{
1899
    AVFormatContext *is = input_files[infile];
1900
    AVFormatContext *os = output_files[outfile];
1901
    int i;
1902

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

    
1910

    
1911
        if (in_ch->end < ts_off)
1912
            continue;
1913
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1914
            break;
1915

    
1916
        out_ch = av_mallocz(sizeof(AVChapter));
1917
        if (!out_ch)
1918
            return AVERROR(ENOMEM);
1919

    
1920
        out_ch->id        = in_ch->id;
1921
        out_ch->time_base = in_ch->time_base;
1922
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1923
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1924

    
1925
        if (metadata_chapters_autocopy)
1926
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1927

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

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

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

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

    
1983
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1984
    if (!file_table)
1985
        goto fail;
1986

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

    
1997
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1998
    if (!ist_table)
1999
        goto fail;
2000

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

    
2018
            if (rate_emu) {
2019
                ist->start = av_gettime();
2020
            }
2021
        }
2022
    }
2023

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

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

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

    
2063
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2064
    if (!ost_table)
2065
        goto fail;
2066

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

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

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

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

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

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

    
2187
        codec = ost->st->codec;
2188
        icodec = ist->st->codec;
2189

    
2190
        if (metadata_streams_autocopy)
2191
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2192
                             AV_METADATA_DONT_OVERWRITE);
2193

    
2194
        ost->st->disposition = ist->st->disposition;
2195
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2196
        codec->chroma_sample_location = icodec->chroma_sample_location;
2197

    
2198
        if (ost->st->stream_copy) {
2199
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2200

    
2201
            if (extra_size > INT_MAX)
2202
                goto fail;
2203

    
2204
            /* if stream_copy is selected, no need to decode or encode */
2205
            codec->codec_id = icodec->codec_id;
2206
            codec->codec_type = icodec->codec_type;
2207

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2588
    timer_start = av_gettime();
2589

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2730
    discard_packet:
2731
        av_free_packet(&pkt);
2732

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

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

    
2745
    term_exit();
2746

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2854
    opt_default(opt, arg);
2855

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

    
2859
    return 0;
2860
}
2861

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

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

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

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

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

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

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

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

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

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

    
2931
    return 0;
2932
}
2933

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3041
    return 0;
3042
}
3043

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3152
    input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);
3153
    input_files_ts_scale[nb_input_files][stream]= scale;
3154
}
3155

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3299
    ic->loop_input = loop_input;
3300

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

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

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

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

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

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

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

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

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

    
3405
    nb_input_files++;
3406

    
3407
    video_channel = 0;
3408

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

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

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

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

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

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

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

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

    
3491
    video_enc = st->codec;
3492

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

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

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

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

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

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

    
3530
        choose_pixel_fmt(st, codec);
3531

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3712
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3713

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3850
        oc->timestamp = recording_timestamp;
3851

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

    
3856
    output_files[nb_output_files++] = oc;
3857

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

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

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

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

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

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

    
3908
    av_freep(&forced_key_frames);
3909
}
3910

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4147

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

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

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

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

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

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

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

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

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

    
4176
        opt_format("dv");
4177

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

    
4183
        audio_sample_rate = 48000;
4184
        audio_channels = 2;
4185

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

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

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

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

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

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

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

    
4225
    *bsfp= bsfc;
4226

    
4227
    return 0;
4228
}
4229

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

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

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

    
4264
    fclose(f);
4265

    
4266
    return 0;
4267
}
4268

    
4269
static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4270
{
4271
}
4272

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

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

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

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

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

    
4393
    /* muxer options */
4394
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4395
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4396

    
4397
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4398
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4399
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4400

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

    
4406
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4407
    { NULL, },
4408
};
4409

    
4410
int main(int argc, char **argv)
4411
{
4412
    int64_t ti;
4413

    
4414
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4415

    
4416
    if(argc>1 && !strcmp(argv[1], "-d")){
4417
        daemon=1;
4418
        verbose=-1;
4419
        av_log_set_callback(log_callback_null);
4420
        argc--;
4421
        argv++;
4422
    }
4423

    
4424
    avcodec_register_all();
4425
#if CONFIG_AVDEVICE
4426
    avdevice_register_all();
4427
#endif
4428
#if CONFIG_AVFILTER
4429
    avfilter_register_all();
4430
#endif
4431
    av_register_all();
4432

    
4433
#if HAVE_ISATTY
4434
    if(isatty(STDIN_FILENO))
4435
        avio_set_interrupt_cb(decode_interrupt_cb);
4436
#endif
4437

    
4438
    init_opts();
4439

    
4440
    show_banner();
4441

    
4442
    /* parse options */
4443
    parse_options(argc, argv, options, opt_output_file);
4444

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

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

    
4457
    if (nb_input_files == 0) {
4458
        fprintf(stderr, "At least one input file must be specified\n");
4459
        ffmpeg_exit(1);
4460
    }
4461

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

    
4472
    return ffmpeg_exit(0);
4473
}