Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ a38cdfde

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 "libavutil/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
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
117

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

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

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

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

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

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

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

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

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

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

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

    
226
static int rate_emu = 0;
227

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

    
231
static int audio_volume = 256;
232

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

    
249
static float dts_delta_threshold = 10;
250

    
251
static int64_t timer_start;
252

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

    
257
static short *samples;
258

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

    
263
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
264

    
265
struct AVInputStream;
266

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

    
288
    float frame_aspect_ratio;
289

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

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

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

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

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

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

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

    
346
#if HAVE_TERMIOS_H
347

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

    
352
#if CONFIG_AVFILTER
353

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

    
365
    ost->graph = avfilter_graph_alloc();
366

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

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

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

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

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

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

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

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

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

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

    
427
    codec->width  = ost->output_video_filter->inputs[0]->w;
428
    codec->height = ost->output_video_filter->inputs[0]->h;
429
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
430
        ost->frame_aspect_ratio ? // overriden by the -aspect cli option
431
        av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
432
        ost->output_video_filter->inputs[0]->sample_aspect_ratio;
433

    
434
    return 0;
435
}
436
#endif /* CONFIG_AVFILTER */
437

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

    
447
static volatile int received_sigterm = 0;
448

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

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

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

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

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

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

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

    
497
    if(run_as_daemon)
498
        return -1;
499

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

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

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

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

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

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

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

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

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

    
559
    av_free(video_standard);
560

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

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

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

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

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

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

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

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

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

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

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

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

    
704
        s->nb_streams++;
705

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

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

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

    
733
        new_output_stream(s, nb_output_files);
734
    }
735

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

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

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

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

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

    
772
        bsfc= bsfc->next;
773
    }
774

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

    
782
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
783

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1155
    *frame_size = 0;
1156

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1379

    
1380
    oc = output_files[0];
1381

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

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

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

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

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

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

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

    
1459
        fflush(stderr);
1460
    }
1461

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1718
                        av_init_packet(&opkt);
1719

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1904

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2453
        int out_file_index = meta_data_maps[i][0].file;
2454
        int in_file_index = meta_data_maps[i][1].file;
2455
        if (in_file_index < 0 || out_file_index < 0)
2456
            continue;
2457
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2458
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2459

    
2460
        files[0] = output_files[out_file_index];
2461
        files[1] = input_files[in_file_index];
2462

    
2463
        for (j = 0; j < 2; j++) {
2464
            AVMetaDataMap *map = &meta_data_maps[i][j];
2465

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

    
2485
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2486
    }
2487

    
2488
    /* copy global metadata by default */
2489
    if (metadata_global_autocopy) {
2490

    
2491
        for (i = 0; i < nb_output_files; i++)
2492
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2493
                             AV_METADATA_DONT_OVERWRITE);
2494
    }
2495

    
2496
    /* copy chapters according to chapter maps */
2497
    for (i = 0; i < nb_chapter_maps; i++) {
2498
        int infile  = chapter_maps[i].in_file;
2499
        int outfile = chapter_maps[i].out_file;
2500

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

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

    
2522
            for (j = 0; j < nb_output_files; j++)
2523
                if ((ret = copy_chapters(i, j)) < 0)
2524
                    goto dump_format;
2525
            break;
2526
        }
2527

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

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

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

    
2566
    if (ret) {
2567
        fprintf(stderr, "%s\n", error);
2568
        goto fail;
2569
    }
2570

    
2571
    if (want_sdp) {
2572
        print_sdp(output_files, nb_output_files);
2573
    }
2574

    
2575
    if (!using_stdin) {
2576
        if(verbose >= 0)
2577
            fprintf(stderr, "Press [q] to stop encoding\n");
2578
        avio_set_interrupt_cb(decode_interrupt_cb);
2579
    }
2580
    term_init();
2581

    
2582
    timer_start = av_gettime();
2583

    
2584
    for(; received_sigterm == 0;) {
2585
        int file_index, ist_index;
2586
        AVPacket pkt;
2587
        double ipts_min;
2588
        double opts_min;
2589

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

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

    
2641
        /* finish if limit size exhausted */
2642
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2643
            break;
2644

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

    
2661
        no_packet_count=0;
2662
        memset(no_packet, 0, sizeof(no_packet));
2663

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

    
2677
        if (pkt.dts != AV_NOPTS_VALUE)
2678
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2679
        if (pkt.pts != AV_NOPTS_VALUE)
2680
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2681

    
2682
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2683
            && input_files_ts_scale[file_index][pkt.stream_index]){
2684
            if(pkt.pts != AV_NOPTS_VALUE)
2685
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2686
            if(pkt.dts != AV_NOPTS_VALUE)
2687
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2688
        }
2689

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

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

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

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

    
2724
    discard_packet:
2725
        av_free_packet(&pkt);
2726

    
2727
        /* dump report by using the output first video and audio streams */
2728
        print_report(output_files, ost_table, nb_ostreams, 0);
2729
    }
2730

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

    
2739
    term_exit();
2740

    
2741
    /* write the trailer if needed and close file */
2742
    for(i=0;i<nb_output_files;i++) {
2743
        os = output_files[i];
2744
        av_write_trailer(os);
2745
    }
2746

    
2747
    /* dump report by using the first video and audio streams */
2748
    print_report(output_files, ost_table, nb_ostreams, 1);
2749

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

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

    
2770
    /* finished ! */
2771
    ret = 0;
2772

    
2773
 fail:
2774
    av_freep(&bit_buffer);
2775
    av_free(file_table);
2776

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

    
2813
static void opt_format(const char *arg)
2814
{
2815
    last_asked_format = arg;
2816
}
2817

    
2818
static void opt_video_rc_override_string(const char *arg)
2819
{
2820
    video_rc_override_string = arg;
2821
}
2822

    
2823
static int opt_me_threshold(const char *opt, const char *arg)
2824
{
2825
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2826
    return 0;
2827
}
2828

    
2829
static int opt_verbose(const char *opt, const char *arg)
2830
{
2831
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2832
    return 0;
2833
}
2834

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

    
2844
static int opt_bitrate(const char *opt, const char *arg)
2845
{
2846
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2847

    
2848
    opt_default(opt, arg);
2849

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

    
2853
    return 0;
2854
}
2855

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

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

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

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

    
2889
static void opt_frame_aspect_ratio(const char *arg)
2890
{
2891
    int x = 0, y = 0;
2892
    double ar = 0;
2893
    const char *p;
2894
    char *end;
2895

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

    
2906
    if (!ar) {
2907
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2908
        ffmpeg_exit(1);
2909
    }
2910
    frame_aspect_ratio = ar;
2911
}
2912

    
2913
static int opt_metadata(const char *opt, const char *arg)
2914
{
2915
    char *mid= strchr(arg, '=');
2916

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

    
2923
    av_metadata_set2(&metadata, arg, mid, 0);
2924

    
2925
    return 0;
2926
}
2927

    
2928
static int opt_qscale(const char *opt, const char *arg)
2929
{
2930
    video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2931
    if (video_qscale <= 0 || video_qscale > 255) {
2932
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2933
        return AVERROR(EINVAL);
2934
    }
2935
    return 0;
2936
}
2937

    
2938
static int opt_top_field_first(const char *opt, const char *arg)
2939
{
2940
    top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2941
    return 0;
2942
}
2943

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

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

    
2971
static int opt_audio_rate(const char *opt, const char *arg)
2972
{
2973
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2974
    return 0;
2975
}
2976

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

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

    
2989
static void opt_video_standard(const char *arg)
2990
{
2991
    video_standard = av_strdup(arg);
2992
}
2993

    
2994
static void opt_codec(int *pstream_copy, char **pcodec_name,
2995
                      int codec_type, const char *arg)
2996
{
2997
    av_freep(pcodec_name);
2998
    if (!strcmp(arg, "copy")) {
2999
        *pstream_copy = 1;
3000
    } else {
3001
        *pcodec_name = av_strdup(arg);
3002
    }
3003
}
3004

    
3005
static void opt_audio_codec(const char *arg)
3006
{
3007
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
3008
}
3009

    
3010
static void opt_video_codec(const char *arg)
3011
{
3012
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
3013
}
3014

    
3015
static void opt_subtitle_codec(const char *arg)
3016
{
3017
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3018
}
3019

    
3020
static int opt_codec_tag(const char *opt, const char *arg)
3021
{
3022
    char *tail;
3023
    uint32_t *codec_tag;
3024

    
3025
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3026
                !strcmp(opt, "vtag") ? &video_codec_tag :
3027
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3028
    if (!codec_tag)
3029
        return -1;
3030

    
3031
    *codec_tag = strtol(arg, &tail, 0);
3032
    if (!tail || *tail)
3033
        *codec_tag = AV_RL32(arg);
3034

    
3035
    return 0;
3036
}
3037

    
3038
static void opt_map(const char *arg)
3039
{
3040
    AVStreamMap *m;
3041
    char *p;
3042

    
3043
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3044
    m = &stream_maps[nb_stream_maps-1];
3045

    
3046
    m->file_index = strtol(arg, &p, 0);
3047
    if (*p)
3048
        p++;
3049

    
3050
    m->stream_index = strtol(p, &p, 0);
3051
    if (*p) {
3052
        p++;
3053
        m->sync_file_index = strtol(p, &p, 0);
3054
        if (*p)
3055
            p++;
3056
        m->sync_stream_index = strtol(p, &p, 0);
3057
    } else {
3058
        m->sync_file_index = m->file_index;
3059
        m->sync_stream_index = m->stream_index;
3060
    }
3061
}
3062

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

    
3084
static void opt_map_metadata(const char *arg)
3085
{
3086
    AVMetaDataMap *m, *m1;
3087
    char *p;
3088

    
3089
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3090
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3091

    
3092
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3093
    m->file = strtol(arg, &p, 0);
3094
    parse_meta_type(p, &m->type, &m->index, &p);
3095
    if (*p)
3096
        p++;
3097

    
3098
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3099
    m1->file = strtol(p, &p, 0);
3100
    parse_meta_type(p, &m1->type, &m1->index, &p);
3101

    
3102
    if (m->type == 'g' || m1->type == 'g')
3103
        metadata_global_autocopy = 0;
3104
    if (m->type == 's' || m1->type == 's')
3105
        metadata_streams_autocopy = 0;
3106
    if (m->type == 'c' || m1->type == 'c')
3107
        metadata_chapters_autocopy = 0;
3108
}
3109

    
3110
static void opt_map_meta_data(const char *arg)
3111
{
3112
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3113
                    "Use -map_metadata instead.\n");
3114
    opt_map_metadata(arg);
3115
}
3116

    
3117
static void opt_map_chapters(const char *arg)
3118
{
3119
    AVChapterMap *c;
3120
    char *p;
3121

    
3122
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3123
                              nb_chapter_maps + 1);
3124
    c = &chapter_maps[nb_chapter_maps - 1];
3125
    c->out_file = strtol(arg, &p, 0);
3126
    if (*p)
3127
        p++;
3128

    
3129
    c->in_file = strtol(p, &p, 0);
3130
}
3131

    
3132
static void opt_input_ts_scale(const char *arg)
3133
{
3134
    unsigned int stream;
3135
    double scale;
3136
    char *p;
3137

    
3138
    stream = strtol(arg, &p, 0);
3139
    if (*p)
3140
        p++;
3141
    scale= strtod(p, &p);
3142

    
3143
    if(stream >= MAX_STREAMS)
3144
        ffmpeg_exit(1);
3145

    
3146
    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);
3147
    input_files_ts_scale[nb_input_files][stream]= scale;
3148
}
3149

    
3150
static int opt_recording_time(const char *opt, const char *arg)
3151
{
3152
    recording_time = parse_time_or_die(opt, arg, 1);
3153
    return 0;
3154
}
3155

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

    
3162
static int opt_recording_timestamp(const char *opt, const char *arg)
3163
{
3164
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3165
    return 0;
3166
}
3167

    
3168
static int opt_input_ts_offset(const char *opt, const char *arg)
3169
{
3170
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3171
    return 0;
3172
}
3173

    
3174
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3175
{
3176
    const char *codec_string = encoder ? "encoder" : "decoder";
3177
    AVCodec *codec;
3178

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

    
3208
static void opt_input_file(const char *filename)
3209
{
3210
    AVFormatContext *ic;
3211
    AVFormatParameters params, *ap = &params;
3212
    AVInputFormat *file_iformat = NULL;
3213
    int err, i, ret, rfps, rfps_base;
3214
    int64_t timestamp;
3215

    
3216
    if (last_asked_format) {
3217
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3218
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3219
            ffmpeg_exit(1);
3220
        }
3221
        last_asked_format = NULL;
3222
    }
3223

    
3224
    if (!strcmp(filename, "-"))
3225
        filename = "pipe:";
3226

    
3227
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3228
                    !strcmp(filename, "/dev/stdin");
3229

    
3230
    /* get default parameters from command line */
3231
    ic = avformat_alloc_context();
3232
    if (!ic) {
3233
        print_error(filename, AVERROR(ENOMEM));
3234
        ffmpeg_exit(1);
3235
    }
3236

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

    
3250
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3251

    
3252
    ic->video_codec_id   =
3253
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3254
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3255
    ic->audio_codec_id   =
3256
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3257
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3258
    ic->subtitle_codec_id=
3259
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3260
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3261
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3262

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

    
3293
    ic->loop_input = loop_input;
3294

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

    
3304
    timestamp = start_time;
3305
    /* add the stream start time */
3306
    if (ic->start_time != AV_NOPTS_VALUE)
3307
        timestamp += ic->start_time;
3308

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

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

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

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

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

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

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

    
3399
    nb_input_files++;
3400

    
3401
    video_channel = 0;
3402

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

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

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

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

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

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

    
3479
    avcodec_get_context_defaults3(st->codec, codec);
3480
    ost->bitstream_filters = video_bitstream_filters;
3481
    video_bitstream_filters= NULL;
3482

    
3483
    st->codec->thread_count= thread_count;
3484

    
3485
    video_enc = st->codec;
3486

    
3487
    if(video_codec_tag)
3488
        video_enc->codec_tag= video_codec_tag;
3489

    
3490
    if(   (video_global_header&1)
3491
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3492
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3493
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3494
    }
3495
    if(video_global_header&2){
3496
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3497
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3498
    }
3499

    
3500
    if (video_stream_copy) {
3501
        st->stream_copy = 1;
3502
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3503
        video_enc->sample_aspect_ratio =
3504
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3505
    } else {
3506
        const char *p;
3507
        int i;
3508
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3509

    
3510
        video_enc->codec_id = codec_id;
3511
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3512

    
3513
        if (codec && codec->supported_framerates && !force_fps)
3514
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3515
        video_enc->time_base.den = fps.num;
3516
        video_enc->time_base.num = fps.den;
3517

    
3518
        video_enc->width = frame_width;
3519
        video_enc->height = frame_height;
3520
        video_enc->pix_fmt = frame_pix_fmt;
3521
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3522
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3523

    
3524
        choose_pixel_fmt(st, codec);
3525

    
3526
        if (intra_only)
3527
            video_enc->gop_size = 0;
3528
        if (video_qscale || same_quality) {
3529
            video_enc->flags |= CODEC_FLAG_QSCALE;
3530
            video_enc->global_quality=
3531
                st->quality = FF_QP2LAMBDA * video_qscale;
3532
        }
3533

    
3534
        if(intra_matrix)
3535
            video_enc->intra_matrix = intra_matrix;
3536
        if(inter_matrix)
3537
            video_enc->inter_matrix = inter_matrix;
3538

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

    
3569
        if (do_psnr)
3570
            video_enc->flags|= CODEC_FLAG_PSNR;
3571

    
3572
        /* two pass mode */
3573
        if (do_pass) {
3574
            if (do_pass == 1) {
3575
                video_enc->flags |= CODEC_FLAG_PASS1;
3576
            } else {
3577
                video_enc->flags |= CODEC_FLAG_PASS2;
3578
            }
3579
        }
3580

    
3581
        if (forced_key_frames)
3582
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3583
    }
3584
    if (video_language) {
3585
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3586
        av_freep(&video_language);
3587
    }
3588

    
3589
    /* reset some key parameters */
3590
    video_disable = 0;
3591
    av_freep(&video_codec_name);
3592
    av_freep(&forced_key_frames);
3593
    video_stream_copy = 0;
3594
    frame_pix_fmt = PIX_FMT_NONE;
3595
}
3596

    
3597
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3598
{
3599
    AVStream *st;
3600
    AVOutputStream *ost;
3601
    AVCodec *codec= NULL;
3602
    AVCodecContext *audio_enc;
3603
    enum CodecID codec_id = CODEC_ID_NONE;
3604

    
3605
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3606
    if (!st) {
3607
        fprintf(stderr, "Could not alloc stream\n");
3608
        ffmpeg_exit(1);
3609
    }
3610
    ost = new_output_stream(oc, file_idx);
3611

    
3612
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3613
    if(!audio_stream_copy){
3614
        if (audio_codec_name) {
3615
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3616
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3617
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3618
            output_codecs[nb_output_codecs-1] = codec;
3619
        } else {
3620
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3621
            codec = avcodec_find_encoder(codec_id);
3622
        }
3623
    }
3624

    
3625
    avcodec_get_context_defaults3(st->codec, codec);
3626

    
3627
    ost->bitstream_filters = audio_bitstream_filters;
3628
    audio_bitstream_filters= NULL;
3629

    
3630
    st->codec->thread_count= thread_count;
3631

    
3632
    audio_enc = st->codec;
3633
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3634

    
3635
    if(audio_codec_tag)
3636
        audio_enc->codec_tag= audio_codec_tag;
3637

    
3638
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3639
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3640
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3641
    }
3642
    if (audio_stream_copy) {
3643
        st->stream_copy = 1;
3644
        audio_enc->channels = audio_channels;
3645
        audio_enc->sample_rate = audio_sample_rate;
3646
    } else {
3647
        audio_enc->codec_id = codec_id;
3648
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3649

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

    
3669
    /* reset some key parameters */
3670
    audio_disable = 0;
3671
    av_freep(&audio_codec_name);
3672
    audio_stream_copy = 0;
3673
}
3674

    
3675
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3676
{
3677
    AVStream *st;
3678
    AVOutputStream *ost;
3679
    AVCodec *codec=NULL;
3680
    AVCodecContext *subtitle_enc;
3681
    enum CodecID codec_id = CODEC_ID_NONE;
3682

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

    
3703
    ost->bitstream_filters = subtitle_bitstream_filters;
3704
    subtitle_bitstream_filters= NULL;
3705

    
3706
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3707

    
3708
    if(subtitle_codec_tag)
3709
        subtitle_enc->codec_tag= subtitle_codec_tag;
3710

    
3711
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3712
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3713
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3714
    }
3715
    if (subtitle_stream_copy) {
3716
        st->stream_copy = 1;
3717
    } else {
3718
        subtitle_enc->codec_id = codec_id;
3719
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3720
    }
3721

    
3722
    if (subtitle_language) {
3723
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3724
        av_freep(&subtitle_language);
3725
    }
3726

    
3727
    subtitle_disable = 0;
3728
    av_freep(&subtitle_codec_name);
3729
    subtitle_stream_copy = 0;
3730
}
3731

    
3732
static int opt_new_stream(const char *opt, const char *arg)
3733
{
3734
    AVFormatContext *oc;
3735
    int file_idx = nb_output_files - 1;
3736
    if (nb_output_files <= 0) {
3737
        fprintf(stderr, "At least one output file must be specified\n");
3738
        ffmpeg_exit(1);
3739
    }
3740
    oc = output_files[file_idx];
3741

    
3742
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3743
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3744
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3745
    else av_assert0(0);
3746
    return 0;
3747
}
3748

    
3749
/* arg format is "output-stream-index:streamid-value". */
3750
static int opt_streamid(const char *opt, const char *arg)
3751
{
3752
    int idx;
3753
    char *p;
3754
    char idx_str[16];
3755

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

    
3772
static void opt_output_file(const char *filename)
3773
{
3774
    AVFormatContext *oc;
3775
    int err, use_video, use_audio, use_subtitle;
3776
    int input_has_video, input_has_audio, input_has_subtitle;
3777
    AVFormatParameters params, *ap = &params;
3778
    AVOutputFormat *file_oformat;
3779

    
3780
    if (!strcmp(filename, "-"))
3781
        filename = "pipe:";
3782

    
3783
    oc = avformat_alloc_context();
3784
    if (!oc) {
3785
        print_error(filename, AVERROR(ENOMEM));
3786
        ffmpeg_exit(1);
3787
    }
3788

    
3789
    if (last_asked_format) {
3790
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3791
        if (!file_oformat) {
3792
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3793
            ffmpeg_exit(1);
3794
        }
3795
        last_asked_format = NULL;
3796
    } else {
3797
        file_oformat = av_guess_format(NULL, filename, NULL);
3798
        if (!file_oformat) {
3799
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3800
                    filename);
3801
            ffmpeg_exit(1);
3802
        }
3803
    }
3804

    
3805
    oc->oformat = file_oformat;
3806
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3807

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

    
3822
        /* disable if no corresponding type found and at least one
3823
           input file */
3824
        if (nb_input_files > 0) {
3825
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3826
                                         &input_has_subtitle);
3827
            if (!input_has_video)
3828
                use_video = 0;
3829
            if (!input_has_audio)
3830
                use_audio = 0;
3831
            if (!input_has_subtitle)
3832
                use_subtitle = 0;
3833
        }
3834

    
3835
        /* manual disable */
3836
        if (audio_disable)    use_audio    = 0;
3837
        if (video_disable)    use_video    = 0;
3838
        if (subtitle_disable) use_subtitle = 0;
3839

    
3840
        if (use_video)    new_video_stream(oc, nb_output_files);
3841
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3842
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3843

    
3844
        oc->timestamp = recording_timestamp;
3845

    
3846
        av_metadata_copy(&oc->metadata, metadata, 0);
3847
        av_metadata_free(&metadata);
3848
    }
3849

    
3850
    output_files[nb_output_files++] = oc;
3851

    
3852
    /* check filename in case of an image number is expected */
3853
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3854
        if (!av_filename_number_test(oc->filename)) {
3855
            print_error(oc->filename, AVERROR(EINVAL));
3856
            ffmpeg_exit(1);
3857
        }
3858
    }
3859

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

    
3882
        /* open the file */
3883
        if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3884
            print_error(filename, err);
3885
            ffmpeg_exit(1);
3886
        }
3887
    }
3888

    
3889
    memset(ap, 0, sizeof(*ap));
3890
    if (av_set_parameters(oc, ap) < 0) {
3891
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3892
                oc->filename);
3893
        ffmpeg_exit(1);
3894
    }
3895

    
3896
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3897
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3898
    oc->loop_output = loop_output;
3899

    
3900
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3901

    
3902
    av_freep(&forced_key_frames);
3903
}
3904

    
3905
/* same option as mencoder */
3906
static int opt_pass(const char *opt, const char *arg)
3907
{
3908
    do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3909
    return 0;
3910
}
3911

    
3912
static int64_t getutime(void)
3913
{
3914
#if HAVE_GETRUSAGE
3915
    struct rusage rusage;
3916

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

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

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

    
3965
static void opt_inter_matrix(const char *arg)
3966
{
3967
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3968
    parse_matrix_coeffs(inter_matrix, arg);
3969
}
3970

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

    
3977
static void show_usage(void)
3978
{
3979
    printf("Hyper fast Audio and Video encoder\n");
3980
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3981
    printf("\n");
3982
}
3983

    
3984
static void show_help(void)
3985
{
3986
    AVCodec *c;
3987
    AVOutputFormat *oformat = NULL;
3988

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

    
4018
    /* individual codec options */
4019
    c = NULL;
4020
    while ((c = av_codec_next(c))) {
4021
        if (c->priv_class) {
4022
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4023
            printf("\n");
4024
        }
4025
    }
4026

    
4027
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4028
    printf("\n");
4029

    
4030
    /* individual muxer options */
4031
    while ((oformat = av_oformat_next(oformat))) {
4032
        if (oformat->priv_class) {
4033
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4034
            printf("\n");
4035
        }
4036
    }
4037

    
4038
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4039
}
4040

    
4041
static void opt_target(const char *arg)
4042
{
4043
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4044
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4045

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

    
4090
    if(norm == UNKNOWN) {
4091
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4092
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4093
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4094
        ffmpeg_exit(1);
4095
    }
4096

    
4097
    if(!strcmp(arg, "vcd")) {
4098

    
4099
        opt_video_codec("mpeg1video");
4100
        opt_audio_codec("mp2");
4101
        opt_format("vcd");
4102

    
4103
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4104
        opt_frame_rate(NULL, frame_rates[norm]);
4105
        opt_default("g", norm == PAL ? "15" : "18");
4106

    
4107
        opt_default("b", "1150000");
4108
        opt_default("maxrate", "1150000");
4109
        opt_default("minrate", "1150000");
4110
        opt_default("bufsize", "327680"); // 40*1024*8;
4111

    
4112
        opt_default("ab", "224000");
4113
        audio_sample_rate = 44100;
4114
        audio_channels = 2;
4115

    
4116
        opt_default("packetsize", "2324");
4117
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4118

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

    
4127
        opt_video_codec("mpeg2video");
4128
        opt_audio_codec("mp2");
4129
        opt_format("svcd");
4130

    
4131
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4132
        opt_frame_rate(NULL, frame_rates[norm]);
4133
        opt_default("g", norm == PAL ? "15" : "18");
4134

    
4135
        opt_default("b", "2040000");
4136
        opt_default("maxrate", "2516000");
4137
        opt_default("minrate", "0"); //1145000;
4138
        opt_default("bufsize", "1835008"); //224*1024*8;
4139
        opt_default("flags", "+scan_offset");
4140

    
4141

    
4142
        opt_default("ab", "224000");
4143
        audio_sample_rate = 44100;
4144

    
4145
        opt_default("packetsize", "2324");
4146

    
4147
    } else if(!strcmp(arg, "dvd")) {
4148

    
4149
        opt_video_codec("mpeg2video");
4150
        opt_audio_codec("ac3");
4151
        opt_format("dvd");
4152

    
4153
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4154
        opt_frame_rate(NULL, frame_rates[norm]);
4155
        opt_default("g", norm == PAL ? "15" : "18");
4156

    
4157
        opt_default("b", "6000000");
4158
        opt_default("maxrate", "9000000");
4159
        opt_default("minrate", "0"); //1500000;
4160
        opt_default("bufsize", "1835008"); //224*1024*8;
4161

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

    
4165
        opt_default("ab", "448000");
4166
        audio_sample_rate = 48000;
4167

    
4168
    } else if(!strncmp(arg, "dv", 2)) {
4169

    
4170
        opt_format("dv");
4171

    
4172
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4173
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4174
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4175
        opt_frame_rate(NULL, frame_rates[norm]);
4176

    
4177
        audio_sample_rate = 48000;
4178
        audio_channels = 2;
4179

    
4180
    } else {
4181
        fprintf(stderr, "Unknown target: %s\n", arg);
4182
        ffmpeg_exit(1);
4183
    }
4184
}
4185

    
4186
static void opt_vstats_file (const char *arg)
4187
{
4188
    av_free (vstats_filename);
4189
    vstats_filename=av_strdup (arg);
4190
}
4191

    
4192
static void opt_vstats (void)
4193
{
4194
    char filename[40];
4195
    time_t today2 = time(NULL);
4196
    struct tm *today = localtime(&today2);
4197

    
4198
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4199
             today->tm_sec);
4200
    opt_vstats_file(filename);
4201
}
4202

    
4203
static int opt_bsf(const char *opt, const char *arg)
4204
{
4205
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4206
    AVBitStreamFilterContext **bsfp;
4207

    
4208
    if(!bsfc){
4209
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4210
        ffmpeg_exit(1);
4211
    }
4212

    
4213
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4214
          *opt == 'a' ? &audio_bitstream_filters :
4215
                        &subtitle_bitstream_filters;
4216
    while(*bsfp)
4217
        bsfp= &(*bsfp)->next;
4218

    
4219
    *bsfp= bsfc;
4220

    
4221
    return 0;
4222
}
4223

    
4224
static int opt_preset(const char *opt, const char *arg)
4225
{
4226
    FILE *f=NULL;
4227
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4228
    char *codec_name = *opt == 'v' ? video_codec_name :
4229
                       *opt == 'a' ? audio_codec_name :
4230
                                     subtitle_codec_name;
4231

    
4232
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4233
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4234
        ffmpeg_exit(1);
4235
    }
4236

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

    
4258
    fclose(f);
4259

    
4260
    return 0;
4261
}
4262

    
4263
static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4264
{
4265
}
4266

    
4267
static void opt_passlogfile(const char *arg)
4268
{
4269
    pass_logfilename_prefix = arg;
4270
    opt_default("passlogfile", arg);
4271
}
4272

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

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

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

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

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

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

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

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

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

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

    
4414
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4415

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

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

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

    
4438
    init_opts();
4439

    
4440
    show_banner();
4441

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

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

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

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

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

    
4472
    return ffmpeg_exit(0);
4473
}