Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ dfc6f5ae

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;
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
    if (   ost->resample_height != ist->st->codec->height
1193
        || ost->resample_width  != ist->st->codec->width
1194
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1195
        av_log(NULL, AV_LOG_INFO,
1196
               "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1197
               ist->file_index, ist->index,
1198
               ost->resample_width  , ost->resample_height  , avcodec_get_pix_fmt_name(ost->resample_pix_fmt),
1199
               ist->st->codec->width, ist->st->codec->height, avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1200
        if(!ost->video_resample)
1201
            ffmpeg_exit(1);
1202
    }
1203

    
1204
#if !CONFIG_AVFILTER
1205
    if (ost->video_resample) {
1206
        final_picture = &ost->pict_tmp;
1207
        if(  ost->resample_height != ist->st->codec->height
1208
          || ost->resample_width  != ist->st->codec->width
1209
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1210

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1382

    
1383
    oc = output_files[0];
1384

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

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

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

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

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

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

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

    
1462
        fflush(stderr);
1463
    }
1464

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1725
                        av_init_packet(&opkt);
1726

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1911

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2589
    timer_start = av_gettime();
2590

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2731
    discard_packet:
2732
        av_free_packet(&pkt);
2733

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

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

    
2746
    term_exit();
2747

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2855
    opt_default(opt, arg);
2856

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

    
2860
    return 0;
2861
}
2862

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

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

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

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

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

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

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

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

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

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

    
2932
    return 0;
2933
}
2934

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3042
    return 0;
3043
}
3044

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3300
    ic->loop_input = loop_input;
3301

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

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

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

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

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

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

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

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

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

    
3406
    nb_input_files++;
3407

    
3408
    video_channel = 0;
3409

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

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

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

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

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

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

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

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

    
3492
    video_enc = st->codec;
3493

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

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

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

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

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

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

    
3531
        choose_pixel_fmt(st, codec);
3532

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3713
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3714

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3851
        oc->timestamp = recording_timestamp;
3852

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

    
3857
    output_files[nb_output_files++] = oc;
3858

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

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

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

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

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

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

    
3909
    av_freep(&forced_key_frames);
3910
}
3911

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4148

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

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

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

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

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

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

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

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

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

    
4177
        opt_format("dv");
4178

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

    
4184
        audio_sample_rate = 48000;
4185
        audio_channels = 2;
4186

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

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

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

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

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

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

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

    
4226
    *bsfp= bsfc;
4227

    
4228
    return 0;
4229
}
4230

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

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

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

    
4265
    fclose(f);
4266

    
4267
    return 0;
4268
}
4269

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

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

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

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

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

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

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

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

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

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

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

    
4415
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4416

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

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

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

    
4439
    init_opts();
4440

    
4441
    show_banner();
4442

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

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

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

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

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

    
4473
    return ffmpeg_exit(0);
4474
}