Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ b25d931a

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

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

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

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

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

    
226
static int rate_emu = 0;
227

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

    
231
static int audio_volume = 256;
232

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

    
248
static float dts_delta_threshold = 10;
249

    
250
static int64_t timer_start;
251

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

    
256
static short *samples;
257

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

    
262
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
263

    
264
struct AVInputStream;
265

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

    
287
    /* full frame size of first frame */
288
    int original_height;
289
    int original_width;
290

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

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

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

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

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

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

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

    
347
#if HAVE_TERMIOS_H
348

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

    
353
#if CONFIG_AVFILTER
354

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

    
366
    ost->graph = avfilter_graph_alloc();
367

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

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

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

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

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

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

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

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

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

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

    
428
    codec->width  = ost->output_video_filter->inputs[0]->w;
429
    codec->height = ost->output_video_filter->inputs[0]->h;
430
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
431
        ost->output_video_filter->inputs[0]->sample_aspect_ratio;
432

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

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

    
445
static volatile int received_sigterm = 0;
446

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
552
    av_free(video_standard);
553

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

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

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

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

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

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

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

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

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

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

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

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

    
696
        s->nb_streams++;
697

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

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

    
722
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
723
            nopts = 1;
724

    
725
        new_output_stream(s, nb_output_files);
726
    }
727

    
728
    if (!nopts)
729
        s->timestamp = av_gettime();
730

    
731
    av_close_input_file(ic);
732
    return 0;
733
}
734

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

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

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

    
764
        bsfc= bsfc->next;
765
    }
766

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

    
774
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
775

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

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

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

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

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

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

    
816
    if (enc->channels != dec->channels)
817
        ost->audio_resample = 1;
818

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

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

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

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

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

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

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

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

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

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

    
958
        frame_bytes = enc->frame_size * osize * enc->channels;
959

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

    
964
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
965

    
966
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
967

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

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

    
989
        ost->sync_opts += size_out / (osize * enc->channels);
990

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

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

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

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

    
1027
    dec = ist->st->codec;
1028

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

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

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

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

    
1054
    if (picture != picture2)
1055
        *picture = *picture2;
1056
    *bufp = buf;
1057
}
1058

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

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

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

    
1081
    enc = ost->st->codec;
1082

    
1083
    if (!subtitle_out) {
1084
        subtitle_out = av_malloc(subtitle_out_max_size);
1085
    }
1086

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

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

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

    
1125
static int bit_buffer_size= 1024*256;
1126
static uint8_t *bit_buffer= NULL;
1127

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

    
1139
    enc = ost->st->codec;
1140
    dec = ist->st->codec;
1141

    
1142
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1143

    
1144
    /* by default, we output a single frame */
1145
    nb_frames = 1;
1146

    
1147
    *frame_size = 0;
1148

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

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

    
1178
    formatted_picture = in_picture;
1179
    final_picture = formatted_picture;
1180
    padding_src = formatted_picture;
1181
    resampling_dst = &ost->pict_tmp;
1182

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

    
1187
        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));
1188
        if(!ost->video_resample)
1189
            ffmpeg_exit(1);
1190
    }
1191

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1371

    
1372
    oc = output_files[0];
1373

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

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

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

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

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

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

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

    
1452
        fflush(stderr);
1453
    }
1454

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

    
1467
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1468
static int output_packet(AVInputStream *ist, int ist_index,
1469
                         AVOutputStream **ost_table, int nb_ostreams,
1470
                         const AVPacket *pkt)
1471
{
1472
    AVFormatContext *os;
1473
    AVOutputStream *ost;
1474
    int ret, i;
1475
    int got_picture;
1476
    AVFrame picture;
1477
    void *buffer_to_free;
1478
    static unsigned int samples_size= 0;
1479
    AVSubtitle subtitle, *subtitle_to_free;
1480
    int64_t pkt_pts = AV_NOPTS_VALUE;
1481
#if CONFIG_AVFILTER
1482
    int frame_available;
1483
#endif
1484

    
1485
    AVPacket avpkt;
1486
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1487

    
1488
    if(ist->next_pts == AV_NOPTS_VALUE)
1489
        ist->next_pts= ist->pts;
1490

    
1491
    if (pkt == NULL) {
1492
        /* EOF handling */
1493
        av_init_packet(&avpkt);
1494
        avpkt.data = NULL;
1495
        avpkt.size = 0;
1496
        goto handle_eof;
1497
    } else {
1498
        avpkt = *pkt;
1499
    }
1500

    
1501
    if(pkt->dts != AV_NOPTS_VALUE)
1502
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1503
    if(pkt->pts != AV_NOPTS_VALUE)
1504
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1505

    
1506
    //while we have more to decode or while the decoder did output something on EOF
1507
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1508
        uint8_t *data_buf, *decoded_data_buf;
1509
        int data_size, decoded_data_size;
1510
    handle_eof:
1511
        ist->pts= ist->next_pts;
1512

    
1513
        if(avpkt.size && avpkt.size != pkt->size &&
1514
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1515
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1516
            ist->showed_multi_packet_warning=1;
1517
        }
1518

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

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

    
1612
        buffer_to_free = NULL;
1613
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1614
            pre_process_video_frame(ist, (AVPicture *)&picture,
1615
                                    &buffer_to_free);
1616
        }
1617

    
1618
#if CONFIG_AVFILTER
1619
        if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
1620
            for(i=0;i<nb_ostreams;i++) {
1621
                ost = ost_table[i];
1622
                if (ost->input_video_filter && ost->source_index == ist_index) {
1623
                    AVRational sar;
1624
                    if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1625
                    else                                  sar = ist->st->codec->sample_aspect_ratio;
1626
                    // add it to be filtered
1627
                    av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1628
                                             ist->pts,
1629
                                             sar);
1630
                }
1631
            }
1632
        }
1633
#endif
1634

    
1635
        // preprocess audio (volume)
1636
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1637
            if (audio_volume != 256) {
1638
                short *volp;
1639
                volp = samples;
1640
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1641
                    int v = ((*volp) * audio_volume + 128) >> 8;
1642
                    if (v < -32768) v = -32768;
1643
                    if (v >  32767) v = 32767;
1644
                    *volp++ = v;
1645
                }
1646
            }
1647
        }
1648

    
1649
        /* frame rate emulation */
1650
        if (rate_emu) {
1651
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1652
            int64_t now = av_gettime() - ist->start;
1653
            if (pts > now)
1654
                usleep(pts - now);
1655
        }
1656
        /* if output time reached then transcode raw format,
1657
           encode packets and output them */
1658
        if (start_time == 0 || ist->pts >= start_time)
1659
            for(i=0;i<nb_ostreams;i++) {
1660
                int frame_size;
1661

    
1662
                ost = ost_table[i];
1663
                if (ost->source_index == ist_index) {
1664
#if CONFIG_AVFILTER
1665
                frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1666
                    !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1667
                while (frame_available) {
1668
                    AVRational ist_pts_tb;
1669
                    if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1670
                        get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1671
                    if (ost->picref)
1672
                        ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1673
#endif
1674
                    os = output_files[ost->file_index];
1675

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

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

    
1706
                        av_init_packet(&opkt);
1707

    
1708
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1709
#if !CONFIG_AVFILTER
1710
                            continue;
1711
#else
1712
                            goto cont;
1713
#endif
1714

    
1715
                        /* no reencoding needed : output the packet directly */
1716
                        /* force the input stream PTS */
1717

    
1718
                        avcodec_get_frame_defaults(&avframe);
1719
                        ost->st->codec->coded_frame= &avframe;
1720
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1721

    
1722
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1723
                            audio_size += data_size;
1724
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1725
                            video_size += data_size;
1726
                            ost->sync_opts++;
1727
                        }
1728

    
1729
                        opkt.stream_index= ost->index;
1730
                        if(pkt->pts != AV_NOPTS_VALUE)
1731
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1732
                        else
1733
                            opkt.pts= AV_NOPTS_VALUE;
1734

    
1735
                        if (pkt->dts == AV_NOPTS_VALUE)
1736
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1737
                        else
1738
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1739
                        opkt.dts -= ost_tb_start_time;
1740

    
1741
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1742
                        opkt.flags= pkt->flags;
1743

    
1744
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1745
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1746
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1747
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1748
                           ) {
1749
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1750
                                opkt.destruct= av_destruct_packet;
1751
                        } else {
1752
                            opkt.data = data_buf;
1753
                            opkt.size = data_size;
1754
                        }
1755

    
1756
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1757
                        ost->st->codec->frame_number++;
1758
                        ost->frame_number++;
1759
                        av_free_packet(&opkt);
1760
                    }
1761
#if CONFIG_AVFILTER
1762
                    cont:
1763
                    frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1764
                                       ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1765
                    if(ost->picref)
1766
                        avfilter_unref_buffer(ost->picref);
1767
                }
1768
#endif
1769
                }
1770
            }
1771

    
1772
        av_free(buffer_to_free);
1773
        /* XXX: allocate the subtitles in the codec ? */
1774
        if (subtitle_to_free) {
1775
            avsubtitle_free(subtitle_to_free);
1776
            subtitle_to_free = NULL;
1777
        }
1778
    }
1779
 discard_packet:
1780
    if (pkt == NULL) {
1781
        /* EOF handling */
1782

    
1783
        for(i=0;i<nb_ostreams;i++) {
1784
            ost = ost_table[i];
1785
            if (ost->source_index == ist_index) {
1786
                AVCodecContext *enc= ost->st->codec;
1787
                os = output_files[ost->file_index];
1788

    
1789
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1790
                    continue;
1791
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1792
                    continue;
1793

    
1794
                if (ost->encoding_needed) {
1795
                    for(;;) {
1796
                        AVPacket pkt;
1797
                        int fifo_bytes;
1798
                        av_init_packet(&pkt);
1799
                        pkt.stream_index= ost->index;
1800

    
1801
                        switch(ost->st->codec->codec_type) {
1802
                        case AVMEDIA_TYPE_AUDIO:
1803
                            fifo_bytes = av_fifo_size(ost->fifo);
1804
                            ret = 0;
1805
                            /* encode any samples remaining in fifo */
1806
                            if (fifo_bytes > 0) {
1807
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1808
                                int fs_tmp = enc->frame_size;
1809

    
1810
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1811
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1812
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1813
                                } else { /* pad */
1814
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1815
                                    if (allocated_audio_buf_size < frame_bytes)
1816
                                        ffmpeg_exit(1);
1817
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1818
                                }
1819

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

    
1852
                        if(ret<=0)
1853
                            break;
1854
                        pkt.data= bit_buffer;
1855
                        pkt.size= ret;
1856
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1857
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1858
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1859
                    }
1860
                }
1861
            }
1862
        }
1863
    }
1864

    
1865
    return 0;
1866
 fail_decode:
1867
    return -1;
1868
}
1869

    
1870
static void print_sdp(AVFormatContext **avc, int n)
1871
{
1872
    char sdp[2048];
1873

    
1874
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1875
    printf("SDP:\n%s\n", sdp);
1876
    fflush(stdout);
1877
}
1878

    
1879
static int copy_chapters(int infile, int outfile)
1880
{
1881
    AVFormatContext *is = input_files[infile];
1882
    AVFormatContext *os = output_files[outfile];
1883
    int i;
1884

    
1885
    for (i = 0; i < is->nb_chapters; i++) {
1886
        AVChapter *in_ch = is->chapters[i], *out_ch;
1887
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1888
                                      AV_TIME_BASE_Q, in_ch->time_base);
1889
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1890
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1891

    
1892

    
1893
        if (in_ch->end < ts_off)
1894
            continue;
1895
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1896
            break;
1897

    
1898
        out_ch = av_mallocz(sizeof(AVChapter));
1899
        if (!out_ch)
1900
            return AVERROR(ENOMEM);
1901

    
1902
        out_ch->id        = in_ch->id;
1903
        out_ch->time_base = in_ch->time_base;
1904
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1905
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1906

    
1907
        if (metadata_chapters_autocopy)
1908
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1909

    
1910
        os->nb_chapters++;
1911
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1912
        if (!os->chapters)
1913
            return AVERROR(ENOMEM);
1914
        os->chapters[os->nb_chapters - 1] = out_ch;
1915
    }
1916
    return 0;
1917
}
1918

    
1919
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1920
                                    AVCodecContext *avctx)
1921
{
1922
    char *p;
1923
    int n = 1, i;
1924
    int64_t t;
1925

    
1926
    for (p = kf; *p; p++)
1927
        if (*p == ',')
1928
            n++;
1929
    ost->forced_kf_count = n;
1930
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1931
    if (!ost->forced_kf_pts) {
1932
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1933
        ffmpeg_exit(1);
1934
    }
1935
    for (i = 0; i < n; i++) {
1936
        p = i ? strchr(p, ',') + 1 : kf;
1937
        t = parse_time_or_die("force_key_frames", p, 1);
1938
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1939
    }
1940
}
1941

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

    
1965
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1966
    if (!file_table)
1967
        goto fail;
1968

    
1969
    /* input stream init */
1970
    j = 0;
1971
    for(i=0;i<nb_input_files;i++) {
1972
        is = input_files[i];
1973
        file_table[i].ist_index = j;
1974
        file_table[i].nb_streams = is->nb_streams;
1975
        j += is->nb_streams;
1976
    }
1977
    nb_istreams = j;
1978

    
1979
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1980
    if (!ist_table)
1981
        goto fail;
1982

    
1983
    for(i=0;i<nb_istreams;i++) {
1984
        ist = av_mallocz(sizeof(AVInputStream));
1985
        if (!ist)
1986
            goto fail;
1987
        ist_table[i] = ist;
1988
    }
1989
    j = 0;
1990
    for(i=0;i<nb_input_files;i++) {
1991
        is = input_files[i];
1992
        for(k=0;k<is->nb_streams;k++) {
1993
            ist = ist_table[j++];
1994
            ist->st = is->streams[k];
1995
            ist->file_index = i;
1996
            ist->index = k;
1997
            ist->discard = 1; /* the stream is discarded by default
1998
                                 (changed later) */
1999

    
2000
            if (rate_emu) {
2001
                ist->start = av_gettime();
2002
            }
2003
        }
2004
    }
2005

    
2006
    /* output stream init */
2007
    nb_ostreams = 0;
2008
    for(i=0;i<nb_output_files;i++) {
2009
        os = output_files[i];
2010
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2011
            av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2012
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2013
            ret = AVERROR(EINVAL);
2014
            goto fail;
2015
        }
2016
        nb_ostreams += os->nb_streams;
2017
    }
2018
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2019
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
2020
        ret = AVERROR(EINVAL);
2021
        goto fail;
2022
    }
2023

    
2024
    /* Sanity check the mapping args -- do the input files & streams exist? */
2025
    for(i=0;i<nb_stream_maps;i++) {
2026
        int fi = stream_maps[i].file_index;
2027
        int si = stream_maps[i].stream_index;
2028

    
2029
        if (fi < 0 || fi > nb_input_files - 1 ||
2030
            si < 0 || si > file_table[fi].nb_streams - 1) {
2031
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2032
            ret = AVERROR(EINVAL);
2033
            goto fail;
2034
        }
2035
        fi = stream_maps[i].sync_file_index;
2036
        si = stream_maps[i].sync_stream_index;
2037
        if (fi < 0 || fi > nb_input_files - 1 ||
2038
            si < 0 || si > file_table[fi].nb_streams - 1) {
2039
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2040
            ret = AVERROR(EINVAL);
2041
            goto fail;
2042
        }
2043
    }
2044

    
2045
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2046
    if (!ost_table)
2047
        goto fail;
2048

    
2049
    for(k=0;k<nb_output_files;k++) {
2050
        os = output_files[k];
2051
        for(i=0;i<os->nb_streams;i++,n++) {
2052
            nb_streams[os->streams[i]->codec->codec_type]++;
2053
        }
2054
    }
2055
    for(step=1<<30; step; step>>=1){
2056
        int found_streams[AVMEDIA_TYPE_NB]={0};
2057
        for(j=0; j<AVMEDIA_TYPE_NB; j++)
2058
            nb_frame_threshold[j] += step;
2059

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

    
2096
                /* Sanity check that the stream types match */
2097
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2098
                    int i= ost->file_index;
2099
                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2100
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2101
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2102
                        ost->file_index, ost->index);
2103
                    ffmpeg_exit(1);
2104
                }
2105

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

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

    
2163
    /* for each output stream, we compute the right encoding parameters */
2164
    for(i=0;i<nb_ostreams;i++) {
2165
        ost = ost_table[i];
2166
        os = output_files[ost->file_index];
2167
        ist = ist_table[ost->source_index];
2168

    
2169
        codec = ost->st->codec;
2170
        icodec = ist->st->codec;
2171

    
2172
        if (metadata_streams_autocopy)
2173
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2174
                             AV_METADATA_DONT_OVERWRITE);
2175

    
2176
        ost->st->disposition = ist->st->disposition;
2177
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2178
        codec->chroma_sample_location = icodec->chroma_sample_location;
2179

    
2180
        if (ost->st->stream_copy) {
2181
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2182

    
2183
            if (extra_size > INT_MAX)
2184
                goto fail;
2185

    
2186
            /* if stream_copy is selected, no need to decode or encode */
2187
            codec->codec_id = icodec->codec_id;
2188
            codec->codec_type = icodec->codec_type;
2189

    
2190
            if(!codec->codec_tag){
2191
                if(   !os->oformat->codec_tag
2192
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2193
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2194
                    codec->codec_tag = icodec->codec_tag;
2195
            }
2196

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

    
2287
                    ost->original_height = icodec->height;
2288
                    ost->original_width  = icodec->width;
2289
#endif
2290
                    codec->bits_per_raw_sample= 0;
2291
                }
2292
                ost->resample_height = icodec->height;
2293
                ost->resample_width  = icodec->width;
2294
                ost->resample_pix_fmt= icodec->pix_fmt;
2295
                ost->encoding_needed = 1;
2296
                ist->decoding_needed = 1;
2297

    
2298
#if CONFIG_AVFILTER
2299
                if (configure_filters(ist, ost)) {
2300
                    fprintf(stderr, "Error opening filters!\n");
2301
                    exit(1);
2302
                }
2303
#endif
2304
                break;
2305
            case AVMEDIA_TYPE_SUBTITLE:
2306
                ost->encoding_needed = 1;
2307
                ist->decoding_needed = 1;
2308
                break;
2309
            default:
2310
                abort();
2311
                break;
2312
            }
2313
            /* two pass mode */
2314
            if (ost->encoding_needed &&
2315
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2316
                char logfilename[1024];
2317
                FILE *f;
2318

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

    
2347
    if (!bit_buffer)
2348
        bit_buffer = av_malloc(bit_buffer_size);
2349
    if (!bit_buffer) {
2350
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2351
                bit_buffer_size);
2352
        ret = AVERROR(ENOMEM);
2353
        goto fail;
2354
    }
2355

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

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

    
2413
    /* init pts */
2414
    for(i=0;i<nb_istreams;i++) {
2415
        AVStream *st;
2416
        ist = ist_table[i];
2417
        st= ist->st;
2418
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2419
        ist->next_pts = AV_NOPTS_VALUE;
2420
        ist->is_start = 1;
2421
    }
2422

    
2423
    /* set meta data information from input file if required */
2424
    for (i=0;i<nb_meta_data_maps;i++) {
2425
        AVFormatContext *files[2];
2426
        AVMetadata      **meta[2];
2427
        int j;
2428

    
2429
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2430
        if ((index) < 0 || (index) >= (nb_elems)) {\
2431
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2432
                     (desc), (index));\
2433
            ret = AVERROR(EINVAL);\
2434
            goto dump_format;\
2435
        }
2436

    
2437
        int out_file_index = meta_data_maps[i][0].file;
2438
        int in_file_index = meta_data_maps[i][1].file;
2439
        if (in_file_index < 0 || out_file_index < 0)
2440
            continue;
2441
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2442
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2443

    
2444
        files[0] = output_files[out_file_index];
2445
        files[1] = input_files[in_file_index];
2446

    
2447
        for (j = 0; j < 2; j++) {
2448
            AVMetaDataMap *map = &meta_data_maps[i][j];
2449

    
2450
            switch (map->type) {
2451
            case 'g':
2452
                meta[j] = &files[j]->metadata;
2453
                break;
2454
            case 's':
2455
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2456
                meta[j] = &files[j]->streams[map->index]->metadata;
2457
                break;
2458
            case 'c':
2459
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2460
                meta[j] = &files[j]->chapters[map->index]->metadata;
2461
                break;
2462
            case 'p':
2463
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2464
                meta[j] = &files[j]->programs[map->index]->metadata;
2465
                break;
2466
            }
2467
        }
2468

    
2469
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2470
    }
2471

    
2472
    /* copy global metadata by default */
2473
    if (metadata_global_autocopy) {
2474

    
2475
        for (i = 0; i < nb_output_files; i++)
2476
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2477
                             AV_METADATA_DONT_OVERWRITE);
2478
    }
2479

    
2480
    /* copy chapters according to chapter maps */
2481
    for (i = 0; i < nb_chapter_maps; i++) {
2482
        int infile  = chapter_maps[i].in_file;
2483
        int outfile = chapter_maps[i].out_file;
2484

    
2485
        if (infile < 0 || outfile < 0)
2486
            continue;
2487
        if (infile >= nb_input_files) {
2488
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2489
            ret = AVERROR(EINVAL);
2490
            goto dump_format;
2491
        }
2492
        if (outfile >= nb_output_files) {
2493
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2494
            ret = AVERROR(EINVAL);
2495
            goto dump_format;
2496
        }
2497
        copy_chapters(infile, outfile);
2498
    }
2499

    
2500
    /* copy chapters from the first input file that has them*/
2501
    if (!nb_chapter_maps)
2502
        for (i = 0; i < nb_input_files; i++) {
2503
            if (!input_files[i]->nb_chapters)
2504
                continue;
2505

    
2506
            for (j = 0; j < nb_output_files; j++)
2507
                if ((ret = copy_chapters(i, j)) < 0)
2508
                    goto dump_format;
2509
            break;
2510
        }
2511

    
2512
    /* open files and write file headers */
2513
    for(i=0;i<nb_output_files;i++) {
2514
        os = output_files[i];
2515
        if (av_write_header(os) < 0) {
2516
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2517
            ret = AVERROR(EINVAL);
2518
            goto dump_format;
2519
        }
2520
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2521
            want_sdp = 0;
2522
        }
2523
    }
2524

    
2525
 dump_format:
2526
    /* dump the file output parameters - cannot be done before in case
2527
       of stream copy */
2528
    for(i=0;i<nb_output_files;i++) {
2529
        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2530
    }
2531

    
2532
    /* dump the stream mapping */
2533
    if (verbose >= 0) {
2534
        fprintf(stderr, "Stream mapping:\n");
2535
        for(i=0;i<nb_ostreams;i++) {
2536
            ost = ost_table[i];
2537
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2538
                    ist_table[ost->source_index]->file_index,
2539
                    ist_table[ost->source_index]->index,
2540
                    ost->file_index,
2541
                    ost->index);
2542
            if (ost->sync_ist != ist_table[ost->source_index])
2543
                fprintf(stderr, " [sync #%d.%d]",
2544
                        ost->sync_ist->file_index,
2545
                        ost->sync_ist->index);
2546
            fprintf(stderr, "\n");
2547
        }
2548
    }
2549

    
2550
    if (ret) {
2551
        fprintf(stderr, "%s\n", error);
2552
        goto fail;
2553
    }
2554

    
2555
    if (want_sdp) {
2556
        print_sdp(output_files, nb_output_files);
2557
    }
2558

    
2559
    if (!using_stdin) {
2560
        if(verbose >= 0)
2561
            fprintf(stderr, "Press [q] to stop encoding\n");
2562
        url_set_interrupt_cb(decode_interrupt_cb);
2563
    }
2564
    term_init();
2565

    
2566
    timer_start = av_gettime();
2567

    
2568
    for(; received_sigterm == 0;) {
2569
        int file_index, ist_index;
2570
        AVPacket pkt;
2571
        double ipts_min;
2572
        double opts_min;
2573

    
2574
    redo:
2575
        ipts_min= 1e100;
2576
        opts_min= 1e100;
2577
        /* if 'q' pressed, exits */
2578
        if (!using_stdin) {
2579
            if (q_pressed)
2580
                break;
2581
            /* read_key() returns 0 on EOF */
2582
            key = read_key();
2583
            if (key == 'q')
2584
                break;
2585
        }
2586

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

    
2625
        /* finish if limit size exhausted */
2626
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2627
            break;
2628

    
2629
        /* read a frame from it and output it in the fifo */
2630
        is = input_files[file_index];
2631
        ret= av_read_frame(is, &pkt);
2632
        if(ret == AVERROR(EAGAIN)){
2633
            no_packet[file_index]=1;
2634
            no_packet_count++;
2635
            continue;
2636
        }
2637
        if (ret < 0) {
2638
            file_table[file_index].eof_reached = 1;
2639
            if (opt_shortest)
2640
                break;
2641
            else
2642
                continue;
2643
        }
2644

    
2645
        no_packet_count=0;
2646
        memset(no_packet, 0, sizeof(no_packet));
2647

    
2648
        if (do_pkt_dump) {
2649
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2650
                             is->streams[pkt.stream_index]);
2651
        }
2652
        /* the following test is needed in case new streams appear
2653
           dynamically in stream : we ignore them */
2654
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2655
            goto discard_packet;
2656
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2657
        ist = ist_table[ist_index];
2658
        if (ist->discard)
2659
            goto discard_packet;
2660

    
2661
        if (pkt.dts != AV_NOPTS_VALUE)
2662
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2663
        if (pkt.pts != AV_NOPTS_VALUE)
2664
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2665

    
2666
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2667
            && input_files_ts_scale[file_index][pkt.stream_index]){
2668
            if(pkt.pts != AV_NOPTS_VALUE)
2669
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2670
            if(pkt.dts != AV_NOPTS_VALUE)
2671
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2672
        }
2673

    
2674
//        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);
2675
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2676
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2677
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2678
            int64_t delta= pkt_dts - ist->next_pts;
2679
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2680
                input_files_ts_offset[ist->file_index]-= delta;
2681
                if (verbose > 2)
2682
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2683
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2684
                if(pkt.pts != AV_NOPTS_VALUE)
2685
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2686
            }
2687
        }
2688

    
2689
        /* finish if recording time exhausted */
2690
        if (recording_time != INT64_MAX &&
2691
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2692
            ist->is_past_recording_time = 1;
2693
            goto discard_packet;
2694
        }
2695

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

    
2699
            if (verbose >= 0)
2700
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2701
                        ist->file_index, ist->index);
2702
            if (exit_on_error)
2703
                ffmpeg_exit(1);
2704
            av_free_packet(&pkt);
2705
            goto redo;
2706
        }
2707

    
2708
    discard_packet:
2709
        av_free_packet(&pkt);
2710

    
2711
        /* dump report by using the output first video and audio streams */
2712
        print_report(output_files, ost_table, nb_ostreams, 0);
2713
    }
2714

    
2715
    /* at the end of stream, we must flush the decoder buffers */
2716
    for(i=0;i<nb_istreams;i++) {
2717
        ist = ist_table[i];
2718
        if (ist->decoding_needed) {
2719
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2720
        }
2721
    }
2722

    
2723
    term_exit();
2724

    
2725
    /* write the trailer if needed and close file */
2726
    for(i=0;i<nb_output_files;i++) {
2727
        os = output_files[i];
2728
        av_write_trailer(os);
2729
    }
2730

    
2731
    /* dump report by using the first video and audio streams */
2732
    print_report(output_files, ost_table, nb_ostreams, 1);
2733

    
2734
    /* close each encoder */
2735
    for(i=0;i<nb_ostreams;i++) {
2736
        ost = ost_table[i];
2737
        if (ost->encoding_needed) {
2738
            av_freep(&ost->st->codec->stats_in);
2739
            avcodec_close(ost->st->codec);
2740
        }
2741
#if CONFIG_AVFILTER
2742
        avfilter_graph_free(&ost->graph);
2743
#endif
2744
    }
2745

    
2746
    /* close each decoder */
2747
    for(i=0;i<nb_istreams;i++) {
2748
        ist = ist_table[i];
2749
        if (ist->decoding_needed) {
2750
            avcodec_close(ist->st->codec);
2751
        }
2752
    }
2753

    
2754
    /* finished ! */
2755
    ret = 0;
2756

    
2757
 fail:
2758
    av_freep(&bit_buffer);
2759
    av_free(file_table);
2760

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

    
2797
static void opt_format(const char *arg)
2798
{
2799
    last_asked_format = arg;
2800
}
2801

    
2802
static void opt_video_rc_override_string(const char *arg)
2803
{
2804
    video_rc_override_string = arg;
2805
}
2806

    
2807
static int opt_me_threshold(const char *opt, const char *arg)
2808
{
2809
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2810
    return 0;
2811
}
2812

    
2813
static int opt_verbose(const char *opt, const char *arg)
2814
{
2815
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2816
    return 0;
2817
}
2818

    
2819
static int opt_frame_rate(const char *opt, const char *arg)
2820
{
2821
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2822
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2823
        ffmpeg_exit(1);
2824
    }
2825
    return 0;
2826
}
2827

    
2828
static int opt_bitrate(const char *opt, const char *arg)
2829
{
2830
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2831

    
2832
    opt_default(opt, arg);
2833

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

    
2837
    return 0;
2838
}
2839

    
2840
static int opt_frame_crop(const char *opt, const char *arg)
2841
{
2842
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2843
    return AVERROR(EINVAL);
2844
}
2845

    
2846
static void opt_frame_size(const char *arg)
2847
{
2848
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2849
        fprintf(stderr, "Incorrect frame size\n");
2850
        ffmpeg_exit(1);
2851
    }
2852
}
2853

    
2854
static int opt_pad(const char *opt, const char *arg) {
2855
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2856
    return -1;
2857
}
2858

    
2859
static void opt_frame_pix_fmt(const char *arg)
2860
{
2861
    if (strcmp(arg, "list")) {
2862
        frame_pix_fmt = av_get_pix_fmt(arg);
2863
        if (frame_pix_fmt == PIX_FMT_NONE) {
2864
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2865
            ffmpeg_exit(1);
2866
        }
2867
    } else {
2868
        show_pix_fmts();
2869
        ffmpeg_exit(0);
2870
    }
2871
}
2872

    
2873
static void opt_frame_aspect_ratio(const char *arg)
2874
{
2875
    int x = 0, y = 0;
2876
    double ar = 0;
2877
    const char *p;
2878
    char *end;
2879

    
2880
    p = strchr(arg, ':');
2881
    if (p) {
2882
        x = strtol(arg, &end, 10);
2883
        if (end == p)
2884
            y = strtol(end+1, &end, 10);
2885
        if (x > 0 && y > 0)
2886
            ar = (double)x / (double)y;
2887
    } else
2888
        ar = strtod(arg, NULL);
2889

    
2890
    if (!ar) {
2891
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2892
        ffmpeg_exit(1);
2893
    }
2894
    frame_aspect_ratio = ar;
2895
    frame_aspect_ratio_override = 1;
2896
}
2897

    
2898
static int opt_metadata(const char *opt, const char *arg)
2899
{
2900
    char *mid= strchr(arg, '=');
2901

    
2902
    if(!mid){
2903
        fprintf(stderr, "Missing =\n");
2904
        ffmpeg_exit(1);
2905
    }
2906
    *mid++= 0;
2907

    
2908
    av_metadata_set2(&metadata, arg, mid, 0);
2909

    
2910
    return 0;
2911
}
2912

    
2913
static void opt_qscale(const char *arg)
2914
{
2915
    video_qscale = atof(arg);
2916
    if (video_qscale <= 0 ||
2917
        video_qscale > 255) {
2918
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2919
        ffmpeg_exit(1);
2920
    }
2921
}
2922

    
2923
static void opt_top_field_first(const char *arg)
2924
{
2925
    top_field_first= atoi(arg);
2926
}
2927

    
2928
static int opt_thread_count(const char *opt, const char *arg)
2929
{
2930
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2931
#if !HAVE_THREADS
2932
    if (verbose >= 0)
2933
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2934
#endif
2935
    return 0;
2936
}
2937

    
2938
static void opt_audio_sample_fmt(const char *arg)
2939
{
2940
    if (strcmp(arg, "list")) {
2941
        audio_sample_fmt = av_get_sample_fmt(arg);
2942
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2943
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2944
            ffmpeg_exit(1);
2945
        }
2946
    } else {
2947
        int i;
2948
        char fmt_str[128];
2949
        for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2950
            printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2951
        ffmpeg_exit(0);
2952
    }
2953
}
2954

    
2955
static int opt_audio_rate(const char *opt, const char *arg)
2956
{
2957
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2958
    return 0;
2959
}
2960

    
2961
static int opt_audio_channels(const char *opt, const char *arg)
2962
{
2963
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2964
    return 0;
2965
}
2966

    
2967
static void opt_video_channel(const char *arg)
2968
{
2969
    video_channel = strtol(arg, NULL, 0);
2970
}
2971

    
2972
static void opt_video_standard(const char *arg)
2973
{
2974
    video_standard = av_strdup(arg);
2975
}
2976

    
2977
static void opt_codec(int *pstream_copy, char **pcodec_name,
2978
                      int codec_type, const char *arg)
2979
{
2980
    av_freep(pcodec_name);
2981
    if (!strcmp(arg, "copy")) {
2982
        *pstream_copy = 1;
2983
    } else {
2984
        *pcodec_name = av_strdup(arg);
2985
    }
2986
}
2987

    
2988
static void opt_audio_codec(const char *arg)
2989
{
2990
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2991
}
2992

    
2993
static void opt_video_codec(const char *arg)
2994
{
2995
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2996
}
2997

    
2998
static void opt_subtitle_codec(const char *arg)
2999
{
3000
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3001
}
3002

    
3003
static int opt_codec_tag(const char *opt, const char *arg)
3004
{
3005
    char *tail;
3006
    uint32_t *codec_tag;
3007

    
3008
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3009
                !strcmp(opt, "vtag") ? &video_codec_tag :
3010
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3011
    if (!codec_tag)
3012
        return -1;
3013

    
3014
    *codec_tag = strtol(arg, &tail, 0);
3015
    if (!tail || *tail)
3016
        *codec_tag = AV_RL32(arg);
3017

    
3018
    return 0;
3019
}
3020

    
3021
static void opt_map(const char *arg)
3022
{
3023
    AVStreamMap *m;
3024
    char *p;
3025

    
3026
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3027
    m = &stream_maps[nb_stream_maps-1];
3028

    
3029
    m->file_index = strtol(arg, &p, 0);
3030
    if (*p)
3031
        p++;
3032

    
3033
    m->stream_index = strtol(p, &p, 0);
3034
    if (*p) {
3035
        p++;
3036
        m->sync_file_index = strtol(p, &p, 0);
3037
        if (*p)
3038
            p++;
3039
        m->sync_stream_index = strtol(p, &p, 0);
3040
    } else {
3041
        m->sync_file_index = m->file_index;
3042
        m->sync_stream_index = m->stream_index;
3043
    }
3044
}
3045

    
3046
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3047
{
3048
    *endptr = arg;
3049
    if (*arg == ',') {
3050
        *type = *(++arg);
3051
        switch (*arg) {
3052
        case 'g':
3053
            break;
3054
        case 's':
3055
        case 'c':
3056
        case 'p':
3057
            *index = strtol(++arg, endptr, 0);
3058
            break;
3059
        default:
3060
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3061
            ffmpeg_exit(1);
3062
        }
3063
    } else
3064
        *type = 'g';
3065
}
3066

    
3067
static void opt_map_metadata(const char *arg)
3068
{
3069
    AVMetaDataMap *m, *m1;
3070
    char *p;
3071

    
3072
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3073
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3074

    
3075
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3076
    m->file = strtol(arg, &p, 0);
3077
    parse_meta_type(p, &m->type, &m->index, &p);
3078
    if (*p)
3079
        p++;
3080

    
3081
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3082
    m1->file = strtol(p, &p, 0);
3083
    parse_meta_type(p, &m1->type, &m1->index, &p);
3084

    
3085
    if (m->type == 'g' || m1->type == 'g')
3086
        metadata_global_autocopy = 0;
3087
    if (m->type == 's' || m1->type == 's')
3088
        metadata_streams_autocopy = 0;
3089
    if (m->type == 'c' || m1->type == 'c')
3090
        metadata_chapters_autocopy = 0;
3091
}
3092

    
3093
static void opt_map_meta_data(const char *arg)
3094
{
3095
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3096
                    "Use -map_metadata instead.\n");
3097
    opt_map_metadata(arg);
3098
}
3099

    
3100
static void opt_map_chapters(const char *arg)
3101
{
3102
    AVChapterMap *c;
3103
    char *p;
3104

    
3105
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3106
                              nb_chapter_maps + 1);
3107
    c = &chapter_maps[nb_chapter_maps - 1];
3108
    c->out_file = strtol(arg, &p, 0);
3109
    if (*p)
3110
        p++;
3111

    
3112
    c->in_file = strtol(p, &p, 0);
3113
}
3114

    
3115
static void opt_input_ts_scale(const char *arg)
3116
{
3117
    unsigned int stream;
3118
    double scale;
3119
    char *p;
3120

    
3121
    stream = strtol(arg, &p, 0);
3122
    if (*p)
3123
        p++;
3124
    scale= strtod(p, &p);
3125

    
3126
    if(stream >= MAX_STREAMS)
3127
        ffmpeg_exit(1);
3128

    
3129
    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);
3130
    input_files_ts_scale[nb_input_files][stream]= scale;
3131
}
3132

    
3133
static int opt_recording_time(const char *opt, const char *arg)
3134
{
3135
    recording_time = parse_time_or_die(opt, arg, 1);
3136
    return 0;
3137
}
3138

    
3139
static int opt_start_time(const char *opt, const char *arg)
3140
{
3141
    start_time = parse_time_or_die(opt, arg, 1);
3142
    return 0;
3143
}
3144

    
3145
static int opt_recording_timestamp(const char *opt, const char *arg)
3146
{
3147
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3148
    return 0;
3149
}
3150

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

    
3157
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3158
{
3159
    const char *codec_string = encoder ? "encoder" : "decoder";
3160
    AVCodec *codec;
3161

    
3162
    if(!name)
3163
        return CODEC_ID_NONE;
3164
    codec = encoder ?
3165
        avcodec_find_encoder_by_name(name) :
3166
        avcodec_find_decoder_by_name(name);
3167
    if(!codec) {
3168
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3169
        ffmpeg_exit(1);
3170
    }
3171
    if(codec->type != type) {
3172
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3173
        ffmpeg_exit(1);
3174
    }
3175
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3176
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3177
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3178
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3179
                codec_string, codec->name);
3180
        codec = encoder ?
3181
            avcodec_find_encoder(codec->id) :
3182
            avcodec_find_decoder(codec->id);
3183
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3184
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3185
                    codec_string, codec->name);
3186
        ffmpeg_exit(1);
3187
    }
3188
    return codec->id;
3189
}
3190

    
3191
static void opt_input_file(const char *filename)
3192
{
3193
    AVFormatContext *ic;
3194
    AVFormatParameters params, *ap = &params;
3195
    AVInputFormat *file_iformat = NULL;
3196
    int err, i, ret, rfps, rfps_base;
3197
    int64_t timestamp;
3198

    
3199
    if (last_asked_format) {
3200
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3201
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3202
            ffmpeg_exit(1);
3203
        }
3204
        last_asked_format = NULL;
3205
    }
3206

    
3207
    if (!strcmp(filename, "-"))
3208
        filename = "pipe:";
3209

    
3210
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3211
                    !strcmp(filename, "/dev/stdin");
3212

    
3213
    /* get default parameters from command line */
3214
    ic = avformat_alloc_context();
3215
    if (!ic) {
3216
        print_error(filename, AVERROR(ENOMEM));
3217
        ffmpeg_exit(1);
3218
    }
3219

    
3220
    memset(ap, 0, sizeof(*ap));
3221
    ap->prealloced_context = 1;
3222
    ap->sample_rate = audio_sample_rate;
3223
    ap->channels = audio_channels;
3224
    ap->time_base.den = frame_rate.num;
3225
    ap->time_base.num = frame_rate.den;
3226
    ap->width = frame_width;
3227
    ap->height = frame_height;
3228
    ap->pix_fmt = frame_pix_fmt;
3229
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3230
    ap->channel = video_channel;
3231
    ap->standard = video_standard;
3232

    
3233
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3234

    
3235
    ic->video_codec_id   =
3236
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3237
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3238
    ic->audio_codec_id   =
3239
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3240
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3241
    ic->subtitle_codec_id=
3242
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3243
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3244
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3245

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

    
3276
    ic->loop_input = loop_input;
3277

    
3278
    /* If not enough info to get the stream parameters, we decode the
3279
       first frames to get it. (used in mpeg case for example) */
3280
    ret = av_find_stream_info(ic);
3281
    if (ret < 0 && verbose >= 0) {
3282
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3283
        av_close_input_file(ic);
3284
        ffmpeg_exit(1);
3285
    }
3286

    
3287
    timestamp = start_time;
3288
    /* add the stream start time */
3289
    if (ic->start_time != AV_NOPTS_VALUE)
3290
        timestamp += ic->start_time;
3291

    
3292
    /* if seeking requested, we execute it */
3293
    if (start_time != 0) {
3294
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3295
        if (ret < 0) {
3296
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3297
                    filename, (double)timestamp / AV_TIME_BASE);
3298
        }
3299
        /* reset seek info */
3300
        start_time = 0;
3301
    }
3302

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

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

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

    
3356
                    (float)rfps / rfps_base, rfps, rfps_base);
3357
            }
3358
            /* update the current frame rate to match the stream frame rate */
3359
            frame_rate.num = rfps;
3360
            frame_rate.den = rfps_base;
3361

    
3362
            if(video_disable)
3363
                st->discard= AVDISCARD_ALL;
3364
            else if(video_discard)
3365
                st->discard= video_discard;
3366
            break;
3367
        case AVMEDIA_TYPE_DATA:
3368
            break;
3369
        case AVMEDIA_TYPE_SUBTITLE:
3370
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3371
            if(subtitle_disable)
3372
                st->discard = AVDISCARD_ALL;
3373
            break;
3374
        case AVMEDIA_TYPE_ATTACHMENT:
3375
        case AVMEDIA_TYPE_UNKNOWN:
3376
            break;
3377
        default:
3378
            abort();
3379
        }
3380
    }
3381

    
3382
    input_files[nb_input_files] = ic;
3383
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3384
    /* dump the file content */
3385
    if (verbose >= 0)
3386
        av_dump_format(ic, nb_input_files, filename, 0);
3387

    
3388
    nb_input_files++;
3389

    
3390
    video_channel = 0;
3391

    
3392
    av_freep(&video_codec_name);
3393
    av_freep(&audio_codec_name);
3394
    av_freep(&subtitle_codec_name);
3395
}
3396

    
3397
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3398
                                         int *has_subtitle_ptr)
3399
{
3400
    int has_video, has_audio, has_subtitle, i, j;
3401
    AVFormatContext *ic;
3402

    
3403
    has_video = 0;
3404
    has_audio = 0;
3405
    has_subtitle = 0;
3406
    for(j=0;j<nb_input_files;j++) {
3407
        ic = input_files[j];
3408
        for(i=0;i<ic->nb_streams;i++) {
3409
            AVCodecContext *enc = ic->streams[i]->codec;
3410
            switch(enc->codec_type) {
3411
            case AVMEDIA_TYPE_AUDIO:
3412
                has_audio = 1;
3413
                break;
3414
            case AVMEDIA_TYPE_VIDEO:
3415
                has_video = 1;
3416
                break;
3417
            case AVMEDIA_TYPE_SUBTITLE:
3418
                has_subtitle = 1;
3419
                break;
3420
            case AVMEDIA_TYPE_DATA:
3421
            case AVMEDIA_TYPE_ATTACHMENT:
3422
            case AVMEDIA_TYPE_UNKNOWN:
3423
                break;
3424
            default:
3425
                abort();
3426
            }
3427
        }
3428
    }
3429
    *has_video_ptr = has_video;
3430
    *has_audio_ptr = has_audio;
3431
    *has_subtitle_ptr = has_subtitle;
3432
}
3433

    
3434
static void new_video_stream(AVFormatContext *oc, int file_idx)
3435
{
3436
    AVStream *st;
3437
    AVOutputStream *ost;
3438
    AVCodecContext *video_enc;
3439
    enum CodecID codec_id = CODEC_ID_NONE;
3440
    AVCodec *codec= NULL;
3441
    int i;
3442

    
3443
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3444
    if (!st) {
3445
        fprintf(stderr, "Could not alloc stream\n");
3446
        ffmpeg_exit(1);
3447
    }
3448
    ost = new_output_stream(oc, file_idx);
3449

    
3450
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3451
    if(!video_stream_copy){
3452
        if (video_codec_name) {
3453
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3454
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3455
            codec = avcodec_find_encoder_by_name(video_codec_name);
3456
            output_codecs[nb_output_codecs-1] = codec;
3457
        } else {
3458
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3459
            codec = avcodec_find_encoder(codec_id);
3460
        }
3461
#if CONFIG_AVFILTER
3462
        if(frame_aspect_ratio_override){
3463
            i = vfilters ? strlen(vfilters) : 0;
3464
            vfilters = av_realloc(vfilters, i+100);
3465
            snprintf(vfilters+i, 100, "%csetdar=%f\n", i?',':' ', frame_aspect_ratio);
3466
            frame_aspect_ratio=0;
3467
            frame_aspect_ratio_override=0;
3468
        }
3469

    
3470
        ost->avfilter= vfilters;
3471
        vfilters= NULL;
3472
#endif
3473
    }
3474

    
3475
    avcodec_get_context_defaults3(st->codec, codec);
3476
    ost->bitstream_filters = video_bitstream_filters;
3477
    video_bitstream_filters= NULL;
3478

    
3479
    st->codec->thread_count= thread_count;
3480

    
3481
    video_enc = st->codec;
3482

    
3483
    if(video_codec_tag)
3484
        video_enc->codec_tag= video_codec_tag;
3485

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

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

    
3506
        video_enc->codec_id = codec_id;
3507
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3508

    
3509
        if (codec && codec->supported_framerates && !force_fps)
3510
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3511
        video_enc->time_base.den = fps.num;
3512
        video_enc->time_base.num = fps.den;
3513

    
3514
        video_enc->width = frame_width;
3515
        video_enc->height = frame_height;
3516
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3517
        video_enc->pix_fmt = frame_pix_fmt;
3518
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3519

    
3520
        choose_pixel_fmt(st, codec);
3521

    
3522
        if (intra_only)
3523
            video_enc->gop_size = 0;
3524
        if (video_qscale || same_quality) {
3525
            video_enc->flags |= CODEC_FLAG_QSCALE;
3526
            video_enc->global_quality=
3527
                st->quality = FF_QP2LAMBDA * video_qscale;
3528
        }
3529

    
3530
        if(intra_matrix)
3531
            video_enc->intra_matrix = intra_matrix;
3532
        if(inter_matrix)
3533
            video_enc->inter_matrix = inter_matrix;
3534

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

    
3565
        if (do_psnr)
3566
            video_enc->flags|= CODEC_FLAG_PSNR;
3567

    
3568
        /* two pass mode */
3569
        if (do_pass) {
3570
            if (do_pass == 1) {
3571
                video_enc->flags |= CODEC_FLAG_PASS1;
3572
            } else {
3573
                video_enc->flags |= CODEC_FLAG_PASS2;
3574
            }
3575
        }
3576

    
3577
        if (forced_key_frames)
3578
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3579
    }
3580
    if (video_language) {
3581
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3582
        av_freep(&video_language);
3583
    }
3584

    
3585
    /* reset some key parameters */
3586
    video_disable = 0;
3587
    av_freep(&video_codec_name);
3588
    av_freep(&forced_key_frames);
3589
    video_stream_copy = 0;
3590
    frame_pix_fmt = PIX_FMT_NONE;
3591
}
3592

    
3593
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3594
{
3595
    AVStream *st;
3596
    AVOutputStream *ost;
3597
    AVCodec *codec= NULL;
3598
    AVCodecContext *audio_enc;
3599
    enum CodecID codec_id = CODEC_ID_NONE;
3600

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

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

    
3621
    avcodec_get_context_defaults3(st->codec, codec);
3622

    
3623
    ost->bitstream_filters = audio_bitstream_filters;
3624
    audio_bitstream_filters= NULL;
3625

    
3626
    st->codec->thread_count= thread_count;
3627

    
3628
    audio_enc = st->codec;
3629
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3630

    
3631
    if(audio_codec_tag)
3632
        audio_enc->codec_tag= audio_codec_tag;
3633

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

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

    
3665
    /* reset some key parameters */
3666
    audio_disable = 0;
3667
    av_freep(&audio_codec_name);
3668
    audio_stream_copy = 0;
3669
}
3670

    
3671
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3672
{
3673
    AVStream *st;
3674
    AVOutputStream *ost;
3675
    AVCodec *codec=NULL;
3676
    AVCodecContext *subtitle_enc;
3677
    enum CodecID codec_id = CODEC_ID_NONE;
3678

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

    
3699
    ost->bitstream_filters = subtitle_bitstream_filters;
3700
    subtitle_bitstream_filters= NULL;
3701

    
3702
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3703

    
3704
    if(subtitle_codec_tag)
3705
        subtitle_enc->codec_tag= subtitle_codec_tag;
3706

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

    
3718
    if (subtitle_language) {
3719
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3720
        av_freep(&subtitle_language);
3721
    }
3722

    
3723
    subtitle_disable = 0;
3724
    av_freep(&subtitle_codec_name);
3725
    subtitle_stream_copy = 0;
3726
}
3727

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

    
3738
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3739
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3740
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3741
    else av_assert0(0);
3742
    return 0;
3743
}
3744

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

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

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

    
3776
    if (!strcmp(filename, "-"))
3777
        filename = "pipe:";
3778

    
3779
    oc = avformat_alloc_context();
3780
    if (!oc) {
3781
        print_error(filename, AVERROR(ENOMEM));
3782
        ffmpeg_exit(1);
3783
    }
3784

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

    
3801
    oc->oformat = file_oformat;
3802
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3803

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

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

    
3831
        /* manual disable */
3832
        if (audio_disable)    use_audio    = 0;
3833
        if (video_disable)    use_video    = 0;
3834
        if (subtitle_disable) use_subtitle = 0;
3835

    
3836
        if (use_video)    new_video_stream(oc, nb_output_files);
3837
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3838
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3839

    
3840
        oc->timestamp = recording_timestamp;
3841

    
3842
        av_metadata_copy(&oc->metadata, metadata, 0);
3843
        av_metadata_free(&metadata);
3844
    }
3845

    
3846
    output_files[nb_output_files++] = oc;
3847

    
3848
    /* check filename in case of an image number is expected */
3849
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3850
        if (!av_filename_number_test(oc->filename)) {
3851
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3852
            ffmpeg_exit(1);
3853
        }
3854
    }
3855

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

    
3878
        /* open the file */
3879
        if ((err = avio_open(&oc->pb, filename, URL_WRONLY)) < 0) {
3880
            print_error(filename, err);
3881
            ffmpeg_exit(1);
3882
        }
3883
    }
3884

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

    
3892
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3893
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3894
    oc->loop_output = loop_output;
3895

    
3896
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3897

    
3898
    av_freep(&forced_key_frames);
3899
}
3900

    
3901
/* same option as mencoder */
3902
static void opt_pass(const char *pass_str)
3903
{
3904
    int pass;
3905
    pass = atoi(pass_str);
3906
    if (pass != 1 && pass != 2) {
3907
        fprintf(stderr, "pass number can be only 1 or 2\n");
3908
        ffmpeg_exit(1);
3909
    }
3910
    do_pass = pass;
3911
}
3912

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4142

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

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

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

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

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

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

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

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

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

    
4171
        opt_format("dv");
4172

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

    
4178
        audio_sample_rate = 48000;
4179
        audio_channels = 2;
4180

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

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

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

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

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

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

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

    
4220
    *bsfp= bsfc;
4221

    
4222
    return 0;
4223
}
4224

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

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

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

    
4259
    fclose(f);
4260

    
4261
    return 0;
4262
}
4263

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

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

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

    
4371
    /* subtitle options */
4372
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4373
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4374
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4375
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4376
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4377

    
4378
    /* grab options */
4379
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4380
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4381
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4382

    
4383
    /* muxer options */
4384
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4385
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4386

    
4387
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4388
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4389
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4390

    
4391
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4392
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4393
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4394
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4395

    
4396
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4397
    { NULL, },
4398
};
4399

    
4400
int main(int argc, char **argv)
4401
{
4402
    int64_t ti;
4403

    
4404
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4405

    
4406
    avcodec_register_all();
4407
#if CONFIG_AVDEVICE
4408
    avdevice_register_all();
4409
#endif
4410
#if CONFIG_AVFILTER
4411
    avfilter_register_all();
4412
#endif
4413
    av_register_all();
4414

    
4415
#if HAVE_ISATTY
4416
    if(isatty(STDIN_FILENO))
4417
        url_set_interrupt_cb(decode_interrupt_cb);
4418
#endif
4419

    
4420
    init_opts();
4421

    
4422
    show_banner();
4423

    
4424
    /* parse options */
4425
    parse_options(argc, argv, options, opt_output_file);
4426

    
4427
    if(nb_output_files <= 0 && nb_input_files == 0) {
4428
        show_usage();
4429
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4430
        ffmpeg_exit(1);
4431
    }
4432

    
4433
    /* file converter / grab */
4434
    if (nb_output_files <= 0) {
4435
        fprintf(stderr, "At least one output file must be specified\n");
4436
        ffmpeg_exit(1);
4437
    }
4438

    
4439
    if (nb_input_files == 0) {
4440
        fprintf(stderr, "At least one input file must be specified\n");
4441
        ffmpeg_exit(1);
4442
    }
4443

    
4444
    ti = getutime();
4445
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4446
                  stream_maps, nb_stream_maps) < 0)
4447
        ffmpeg_exit(1);
4448
    ti = getutime() - ti;
4449
    if (do_benchmark) {
4450
        int maxrss = getmaxrss() / 1024;
4451
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4452
    }
4453

    
4454
    return ffmpeg_exit(0);
4455
}