Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 6b1c886b

History | View | Annotate | Download (163 KB)

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

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

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

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

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

    
68
#if HAVE_SYS_SELECT_H
69
#include <sys/select.h>
70
#endif
71

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

    
82
#include "cmdutils.h"
83

    
84
#include "libavutil/avassert.h"
85

    
86
const char program_name[] = "FFmpeg";
87
const int program_birth_year = 2000;
88

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

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

    
106
typedef struct AVChapterMap {
107
    int in_file;
108
    int out_file;
109
} AVChapterMap;
110

    
111
static const OptionDef options[];
112

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

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

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

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

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

    
227
static int rate_emu = 0;
228

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

    
232
static int audio_volume = 256;
233

    
234
static int exit_on_error = 0;
235
static int using_stdin = 0;
236
static int verbose = 1;
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
    /* full frame size of first frame */
289
    int original_height;
290
    int original_width;
291

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

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

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

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

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

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

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

    
348
#if HAVE_TERMIOS_H
349

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

    
354
#if CONFIG_AVFILTER
355

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

    
367
    ost->graph = avfilter_graph_alloc();
368

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

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

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

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

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

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

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

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

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

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

    
429
    codec->width  = ost->output_video_filter->inputs[0]->w;
430
    codec->height = ost->output_video_filter->inputs[0]->h;
431
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
432
        ost->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
    tcsetattr (0, TCSANOW, &oldtty);
443
#endif
444
}
445

    
446
static volatile int received_sigterm = 0;
447

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

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

    
461
    tcgetattr (0, &tty);
462
    oldtty = tty;
463
    atexit(term_exit);
464

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

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

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

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

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

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

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

    
519
static int ffmpeg_exit(int ret)
520
{
521
    int i;
522

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

    
536
    av_free(intra_matrix);
537
    av_free(inter_matrix);
538

    
539
    if (vstats_file)
540
        fclose(vstats_file);
541
    av_free(vstats_filename);
542

    
543
    av_free(streamid_map);
544
    av_free(input_codecs);
545
    av_free(output_codecs);
546
    av_free(stream_maps);
547
    av_free(meta_data_maps);
548

    
549
    av_free(video_codec_name);
550
    av_free(audio_codec_name);
551
    av_free(subtitle_codec_name);
552

    
553
    av_free(video_standard);
554

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

    
561
#if CONFIG_AVFILTER
562
    avfilter_uninit();
563
#endif
564

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

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

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

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

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

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

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

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

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

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

    
698
        s->nb_streams++;
699

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

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

    
724
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
725
            nopts = 1;
726

    
727
        new_output_stream(s, nb_output_files);
728
    }
729

    
730
    if (!nopts)
731
        s->timestamp = av_gettime();
732

    
733
    av_close_input_file(ic);
734
    return 0;
735
}
736

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

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

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

    
766
        bsfc= bsfc->next;
767
    }
768

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

    
776
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
777

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

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

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

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

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

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

    
818
    if (enc->channels != dec->channels)
819
        ost->audio_resample = 1;
820

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

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

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

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

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

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

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

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

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

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

    
960
        frame_bytes = enc->frame_size * osize * enc->channels;
961

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

    
966
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
967

    
968
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
969

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

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

    
991
        ost->sync_opts += size_out / (osize * enc->channels);
992

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

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

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

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

    
1029
    dec = ist->st->codec;
1030

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

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

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

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

    
1056
    if (picture != picture2)
1057
        *picture = *picture2;
1058
    *bufp = buf;
1059
}
1060

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

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

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

    
1083
    enc = ost->st->codec;
1084

    
1085
    if (!subtitle_out) {
1086
        subtitle_out = av_malloc(subtitle_out_max_size);
1087
    }
1088

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

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

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

    
1127
static int bit_buffer_size= 1024*256;
1128
static uint8_t *bit_buffer= NULL;
1129

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

    
1141
    enc = ost->st->codec;
1142
    dec = ist->st->codec;
1143

    
1144
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1145

    
1146
    /* by default, we output a single frame */
1147
    nb_frames = 1;
1148

    
1149
    *frame_size = 0;
1150

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

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

    
1180
    formatted_picture = in_picture;
1181
    final_picture = formatted_picture;
1182
    padding_src = formatted_picture;
1183
    resampling_dst = &ost->pict_tmp;
1184

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

    
1189
        fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width,     ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
1190
        if(!ost->video_resample)
1191
            ffmpeg_exit(1);
1192
    }
1193

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1373

    
1374
    oc = output_files[0];
1375

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

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

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

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

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

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

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

    
1453
        fflush(stderr);
1454
    }
1455

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

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

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

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

    
1497
    if(ist->next_pts == AV_NOPTS_VALUE)
1498
        ist->next_pts= ist->pts;
1499

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1716
                        av_init_packet(&opkt);
1717

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

    
1725
                        /* no reencoding needed : output the packet directly */
1726
                        /* force the input stream PTS */
1727

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1875
    return 0;
1876
 fail_decode:
1877
    return -1;
1878
}
1879

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

    
1884
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1885
    printf("SDP:\n%s\n", sdp);
1886
    fflush(stdout);
1887
}
1888

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

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

    
1902

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

    
1908
        out_ch = av_mallocz(sizeof(AVChapter));
1909
        if (!out_ch)
1910
            return AVERROR(ENOMEM);
1911

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

    
1917
        if (metadata_chapters_autocopy)
1918
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1919

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2179
        codec = ost->st->codec;
2180
        icodec = ist->st->codec;
2181

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

    
2186
        ost->st->disposition = ist->st->disposition;
2187
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2188
        codec->chroma_sample_location = icodec->chroma_sample_location;
2189

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

    
2193
            if (extra_size > INT_MAX)
2194
                goto fail;
2195

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2454
        files[0] = output_files[out_file_index];
2455
        files[1] = input_files[in_file_index];
2456

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

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

    
2479
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2480
    }
2481

    
2482
    /* copy global metadata by default */
2483
    if (metadata_global_autocopy) {
2484

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

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

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

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

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

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

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

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

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

    
2565
    if (want_sdp) {
2566
        print_sdp(output_files, nb_output_files);
2567
    }
2568

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

    
2576
    timer_start = av_gettime();
2577

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

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

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

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

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

    
2655
        no_packet_count=0;
2656
        memset(no_packet, 0, sizeof(no_packet));
2657

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

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

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

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

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

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

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

    
2718
    discard_packet:
2719
        av_free_packet(&pkt);
2720

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

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

    
2733
    term_exit();
2734

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

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

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

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

    
2764
    /* finished ! */
2765
    ret = 0;
2766

    
2767
 fail:
2768
    av_freep(&bit_buffer);
2769
    av_free(file_table);
2770

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

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

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

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

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

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

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

    
2842
    opt_default(opt, arg);
2843

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

    
2847
    return 0;
2848
}
2849

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

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

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

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

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

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

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

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

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

    
2918
    av_metadata_set2(&metadata, arg, mid, 0);
2919

    
2920
    return 0;
2921
}
2922

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3028
    return 0;
3029
}
3030

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

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

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

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

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

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

    
3082
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3083
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3084

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

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

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

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

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

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

    
3122
    c->in_file = strtol(p, &p, 0);
3123
}
3124

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

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

    
3136
    if(stream >= MAX_STREAMS)
3137
        ffmpeg_exit(1);
3138

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

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

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

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

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

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

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

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

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

    
3217
    if (!strcmp(filename, "-"))
3218
        filename = "pipe:";
3219

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

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

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

    
3243
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3244

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

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

    
3286
    ic->loop_input = loop_input;
3287

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

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

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

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

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

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

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

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

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

    
3398
    nb_input_files++;
3399

    
3400
    video_channel = 0;
3401

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

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

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

    
3444
static void new_video_stream(AVFormatContext *oc, int file_idx)
3445
{
3446
    AVStream *st;
3447
    AVOutputStream *ost;
3448
    AVCodecContext *video_enc;
3449
    enum CodecID codec_id = CODEC_ID_NONE;
3450
    AVCodec *codec= NULL;
3451
    int i;
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
#if CONFIG_AVFILTER
3472
        if(frame_aspect_ratio_override){
3473
            i = vfilters ? strlen(vfilters) : 0;
3474
            vfilters = av_realloc(vfilters, i+100);
3475
            snprintf(vfilters+i, 100, "%csetdar=%f\n", i?',':' ', frame_aspect_ratio);
3476
            frame_aspect_ratio=0;
3477
            frame_aspect_ratio_override=0;
3478
        }
3479

    
3480
        ost->avfilter= vfilters;
3481
        vfilters= NULL;
3482
#endif
3483
    }
3484

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

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

    
3491
    video_enc = st->codec;
3492

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

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

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

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

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

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

    
3531
        choose_pixel_fmt(st, codec);
3532

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3713
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3714

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3851
        oc->timestamp = recording_timestamp;
3852

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

    
3857
    output_files[nb_output_files++] = oc;
3858

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

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

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

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

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

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

    
3909
    av_freep(&forced_key_frames);
3910
}
3911

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4050
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4051
}
4052

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

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

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

    
4109
    if(!strcmp(arg, "vcd")) {
4110

    
4111
        opt_video_codec("mpeg1video");
4112
        opt_audio_codec("mp2");
4113
        opt_format("vcd");
4114

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

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

    
4124
        opt_default("ab", "224000");
4125
        audio_sample_rate = 44100;
4126
        audio_channels = 2;
4127

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

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

    
4139
        opt_video_codec("mpeg2video");
4140
        opt_audio_codec("mp2");
4141
        opt_format("svcd");
4142

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

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

    
4153

    
4154
        opt_default("ab", "224000");
4155
        audio_sample_rate = 44100;
4156

    
4157
        opt_default("packetsize", "2324");
4158

    
4159
    } else if(!strcmp(arg, "dvd")) {
4160

    
4161
        opt_video_codec("mpeg2video");
4162
        opt_audio_codec("ac3");
4163
        opt_format("dvd");
4164

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

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

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

    
4177
        opt_default("ab", "448000");
4178
        audio_sample_rate = 48000;
4179

    
4180
    } else if(!strncmp(arg, "dv", 2)) {
4181

    
4182
        opt_format("dv");
4183

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

    
4189
        audio_sample_rate = 48000;
4190
        audio_channels = 2;
4191

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

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

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

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

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

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

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

    
4231
    *bsfp= bsfc;
4232

    
4233
    return 0;
4234
}
4235

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

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

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

    
4270
    fclose(f);
4271

    
4272
    return 0;
4273
}
4274

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

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

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

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

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

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

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

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

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

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

    
4416
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4417

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

    
4427
#if HAVE_ISATTY
4428
    if(isatty(STDIN_FILENO))
4429
        url_set_interrupt_cb(decode_interrupt_cb);
4430
#endif
4431

    
4432
    init_opts();
4433

    
4434
    show_banner();
4435

    
4436
    /* parse options */
4437
    parse_options(argc, argv, options, opt_output_file);
4438

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

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

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

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

    
4466
    return ffmpeg_exit(0);
4467
}