Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 91e96eba

History | View | Annotate | Download (156 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 "libavcore/parseutils.h"
40
#include "libavcore/samplefmt.h"
41
#include "libavutil/colorspace.h"
42
#include "libavutil/fifo.h"
43
#include "libavutil/intreadwrite.h"
44
#include "libavutil/pixdesc.h"
45
#include "libavutil/avstring.h"
46
#include "libavutil/libm.h"
47
#include "libavformat/os_support.h"
48

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

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

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

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

    
81
#include "cmdutils.h"
82

    
83
#include "libavutil/avassert.h"
84

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

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

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

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

    
110
static const OptionDef options[];
111

    
112
#define MAX_FILES 100
113
#if !FF_API_MAX_STREAMS
114
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
115
#endif
116

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

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

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

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

    
140
static AVChapterMap *chapter_maps = NULL;
141
static int nb_chapter_maps;
142

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

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

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

    
187
static int subtitle_disable = 0;
188
static char *subtitle_codec_name = NULL;
189
static char *subtitle_language = NULL;
190
static unsigned int subtitle_codec_tag = 0;
191

    
192
static float mux_preload= 0.5;
193
static float mux_max_delay= 0.7;
194

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

    
221
static int rate_emu = 0;
222

    
223
static int  video_channel = 0;
224
static char *video_standard;
225

    
226
static int audio_volume = 256;
227

    
228
static int exit_on_error = 0;
229
static int using_stdin = 0;
230
static int verbose = 1;
231
static int thread_count= 1;
232
static int q_pressed = 0;
233
static int64_t video_size = 0;
234
static int64_t audio_size = 0;
235
static int64_t extra_size = 0;
236
static int nb_frames_dup = 0;
237
static int nb_frames_drop = 0;
238
static int input_sync;
239
static uint64_t limit_filesize = 0;
240
static int force_fps = 0;
241
static char *forced_key_frames = NULL;
242

    
243
static float dts_delta_threshold = 10;
244

    
245
static unsigned int sws_flags = SWS_BICUBIC;
246

    
247
static int64_t timer_start;
248

    
249
static uint8_t *audio_buf;
250
static uint8_t *audio_out;
251
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
252

    
253
static short *samples;
254

    
255
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
256
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
257
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
258

    
259
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
260

    
261
struct AVInputStream;
262

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

    
284
    /* full frame size of first frame */
285
    int original_height;
286
    int original_width;
287

    
288
    /* forced key frames */
289
    int64_t *forced_kf_pts;
290
    int forced_kf_count;
291
    int forced_kf_index;
292

    
293
    /* audio only */
294
    int audio_resample;
295
    ReSampleContext *resample; /* for audio resampling */
296
    int reformat_pair;
297
    AVAudioConvert *reformat_ctx;
298
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
299
    FILE *logfile;
300
} AVOutputStream;
301

    
302
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
303
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
304

    
305
typedef struct AVInputStream {
306
    int file_index;
307
    int index;
308
    AVStream *st;
309
    int discard;             /* true if stream data should be discarded */
310
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
311
    int64_t sample_index;      /* current sample */
312

    
313
    int64_t       start;     /* time when read started */
314
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
315
                                is not defined */
316
    int64_t       pts;       /* current pts */
317
    PtsCorrectionContext pts_ctx;
318
    int is_start;            /* is 1 at the start and after a discontinuity */
319
    int showed_multi_packet_warning;
320
    int is_past_recording_time;
321
#if CONFIG_AVFILTER
322
    AVFilterContext *output_video_filter;
323
    AVFilterContext *input_video_filter;
324
    AVFrame *filter_frame;
325
    int has_filter_frame;
326
    AVFilterBufferRef *picref;
327
#endif
328
} AVInputStream;
329

    
330
typedef struct AVInputFile {
331
    int eof_reached;      /* true if eof reached */
332
    int ist_index;        /* index of first stream in ist_table */
333
    int buffer_size;      /* current total buffer size */
334
    int nb_streams;       /* nb streams we are aware of */
335
} AVInputFile;
336

    
337
#if HAVE_TERMIOS_H
338

    
339
/* init terminal so that we can grab keys */
340
static struct termios oldtty;
341
#endif
342

    
343
#if CONFIG_AVFILTER
344

    
345
static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
346
{
347
    AVFilterContext *last_filter, *filter;
348
    /** filter graph containing all filters including input & output */
349
    AVCodecContext *codec = ost->st->codec;
350
    AVCodecContext *icodec = ist->st->codec;
351
    FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
352
    char args[255];
353
    int ret;
354

    
355
    graph = avfilter_graph_alloc();
356

    
357
    if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
358
        return ret;
359
    if ((ret = avfilter_open(&ist->output_video_filter, &ffsink, "out")) < 0)
360
        return ret;
361

    
362
    snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
363
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
364
    if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
365
        return ret;
366
    if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &ffsink_ctx)) < 0)
367
        return ret;
368

    
369
    /* add input and output filters to the overall graph */
370
    avfilter_graph_add_filter(graph, ist->input_video_filter);
371
    avfilter_graph_add_filter(graph, ist->output_video_filter);
372

    
373
    last_filter = ist->input_video_filter;
374

    
375
    if (codec->width  != icodec->width || codec->height != icodec->height) {
376
        snprintf(args, 255, "%d:%d:flags=0x%X",
377
                 codec->width,
378
                 codec->height,
379
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
380
        if ((ret = avfilter_open(&filter, avfilter_get_by_name("scale"), NULL)) < 0)
381
            return ret;
382
        if ((ret = avfilter_init_filter(filter, args, NULL)) < 0)
383
            return ret;
384
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
385
            return ret;
386
        last_filter = filter;
387
        avfilter_graph_add_filter(graph, last_filter);
388
    }
389

    
390
    snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
391
    graph->scale_sws_opts = av_strdup(args);
392

    
393
    if (vfilters) {
394
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
395
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
396

    
397
        outputs->name    = av_strdup("in");
398
        outputs->filter_ctx = last_filter;
399
        outputs->pad_idx = 0;
400
        outputs->next    = NULL;
401

    
402
        inputs->name    = av_strdup("out");
403
        inputs->filter_ctx = ist->output_video_filter;
404
        inputs->pad_idx = 0;
405
        inputs->next    = NULL;
406

    
407
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
408
            return ret;
409
        av_freep(&vfilters);
410
    } else {
411
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
412
            return ret;
413
    }
414

    
415
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
416
        return ret;
417

    
418
    codec->width  = ist->output_video_filter->inputs[0]->w;
419
    codec->height = ist->output_video_filter->inputs[0]->h;
420

    
421
    return 0;
422
}
423
#endif /* CONFIG_AVFILTER */
424

    
425
static void term_exit(void)
426
{
427
    av_log(NULL, AV_LOG_QUIET, "");
428
#if HAVE_TERMIOS_H
429
    tcsetattr (0, TCSANOW, &oldtty);
430
#endif
431
}
432

    
433
static volatile int received_sigterm = 0;
434

    
435
static void
436
sigterm_handler(int sig)
437
{
438
    received_sigterm = sig;
439
    term_exit();
440
}
441

    
442
static void term_init(void)
443
{
444
#if HAVE_TERMIOS_H
445
    struct termios tty;
446

    
447
    tcgetattr (0, &tty);
448
    oldtty = tty;
449
    atexit(term_exit);
450

    
451
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
452
                          |INLCR|IGNCR|ICRNL|IXON);
453
    tty.c_oflag |= OPOST;
454
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
455
    tty.c_cflag &= ~(CSIZE|PARENB);
456
    tty.c_cflag |= CS8;
457
    tty.c_cc[VMIN] = 1;
458
    tty.c_cc[VTIME] = 0;
459

    
460
    tcsetattr (0, TCSANOW, &tty);
461
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
462
#endif
463

    
464
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
465
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
466
#ifdef SIGXCPU
467
    signal(SIGXCPU, sigterm_handler);
468
#endif
469
}
470

    
471
/* read a key without blocking */
472
static int read_key(void)
473
{
474
#if HAVE_TERMIOS_H
475
    int n = 1;
476
    unsigned char ch;
477
    struct timeval tv;
478
    fd_set rfds;
479

    
480
    FD_ZERO(&rfds);
481
    FD_SET(0, &rfds);
482
    tv.tv_sec = 0;
483
    tv.tv_usec = 0;
484
    n = select(1, &rfds, NULL, NULL, &tv);
485
    if (n > 0) {
486
        n = read(0, &ch, 1);
487
        if (n == 1)
488
            return ch;
489

    
490
        return n;
491
    }
492
#elif HAVE_CONIO_H
493
    if(kbhit())
494
        return(getch());
495
#endif
496
    return -1;
497
}
498

    
499
static int decode_interrupt_cb(void)
500
{
501
    return q_pressed || (q_pressed = read_key() == 'q');
502
}
503

    
504
static int ffmpeg_exit(int ret)
505
{
506
    int i;
507

    
508
    /* close files */
509
    for(i=0;i<nb_output_files;i++) {
510
        /* maybe av_close_output_file ??? */
511
        AVFormatContext *s = output_files[i];
512
        int j;
513
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
514
            url_fclose(s->pb);
515
        for(j=0;j<s->nb_streams;j++) {
516
            av_metadata_free(&s->streams[j]->metadata);
517
            av_free(s->streams[j]->codec);
518
            av_free(s->streams[j]->info);
519
            av_free(s->streams[j]);
520
        }
521
        for(j=0;j<s->nb_programs;j++) {
522
            av_metadata_free(&s->programs[j]->metadata);
523
        }
524
        for(j=0;j<s->nb_chapters;j++) {
525
            av_metadata_free(&s->chapters[j]->metadata);
526
        }
527
        av_metadata_free(&s->metadata);
528
        av_free(s);
529
        av_free(output_streams_for_file[i]);
530
    }
531
    for(i=0;i<nb_input_files;i++) {
532
        av_close_input_file(input_files[i]);
533
        av_free(input_files_ts_scale[i]);
534
    }
535

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

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

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

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

    
554
    av_free(video_standard);
555

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

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

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

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

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

    
597
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
598
{
599
    if(codec && codec->sample_fmts){
600
        const enum SampleFormat *p= codec->sample_fmts;
601
        for(; *p!=-1; p++){
602
            if(*p == st->codec->sample_fmt)
603
                break;
604
        }
605
        if(*p == -1)
606
            st->codec->sample_fmt = codec->sample_fmts[0];
607
    }
608
}
609

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

    
630
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
631
{
632
    if(codec && codec->pix_fmts){
633
        const enum PixelFormat *p= codec->pix_fmts;
634
        for(; *p!=-1; p++){
635
            if(*p == st->codec->pix_fmt)
636
                break;
637
        }
638
        if(*p == -1
639
           && !(   st->codec->codec_id==CODEC_ID_MJPEG
640
                && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL
641
                && (   st->codec->pix_fmt == PIX_FMT_YUV420P
642
                    || st->codec->pix_fmt == PIX_FMT_YUV422P)))
643
            st->codec->pix_fmt = codec->pix_fmts[0];
644
    }
645
}
646

    
647
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
648
{
649
    int idx = oc->nb_streams - 1;
650
    AVOutputStream *ost;
651

    
652
    output_streams_for_file[file_idx] =
653
        grow_array(output_streams_for_file[file_idx],
654
                   sizeof(*output_streams_for_file[file_idx]),
655
                   &nb_output_streams_for_file[file_idx],
656
                   oc->nb_streams);
657
    ost = output_streams_for_file[file_idx][idx] =
658
        av_mallocz(sizeof(AVOutputStream));
659
    if (!ost) {
660
        fprintf(stderr, "Could not alloc output stream\n");
661
        ffmpeg_exit(1);
662
    }
663
    ost->file_index = file_idx;
664
    ost->index = idx;
665
    return ost;
666
}
667

    
668
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
669
{
670
    int i, err;
671
    AVFormatContext *ic;
672
    int nopts = 0;
673

    
674
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
675
    if (err < 0)
676
        return err;
677
    /* copy stream format */
678
    s->nb_streams = 0;
679
    for(i=0;i<ic->nb_streams;i++) {
680
        AVStream *st;
681
        AVCodec *codec;
682

    
683
        s->nb_streams++;
684

    
685
        // FIXME: a more elegant solution is needed
686
        st = av_mallocz(sizeof(AVStream));
687
        memcpy(st, ic->streams[i], sizeof(AVStream));
688
        st->codec = avcodec_alloc_context();
689
        if (!st->codec) {
690
            print_error(filename, AVERROR(ENOMEM));
691
            ffmpeg_exit(1);
692
        }
693
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
694
        s->streams[i] = st;
695

    
696
        codec = avcodec_find_encoder(st->codec->codec_id);
697
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
698
            if (audio_stream_copy) {
699
                st->stream_copy = 1;
700
            } else
701
                choose_sample_fmt(st, codec);
702
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
703
            if (video_stream_copy) {
704
                st->stream_copy = 1;
705
            } else
706
                choose_pixel_fmt(st, codec);
707
        }
708

    
709
        if(!st->codec->thread_count)
710
            st->codec->thread_count = 1;
711
        if(st->codec->thread_count>1)
712
            avcodec_thread_init(st->codec, st->codec->thread_count);
713

    
714
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
715
            nopts = 1;
716

    
717
        new_output_stream(s, nb_output_files);
718
    }
719

    
720
    if (!nopts)
721
        s->timestamp = av_gettime();
722

    
723
    av_close_input_file(ic);
724
    return 0;
725
}
726

    
727
static double
728
get_sync_ipts(const AVOutputStream *ost)
729
{
730
    const AVInputStream *ist = ost->sync_ist;
731
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
732
}
733

    
734
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
735
    int ret;
736

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

    
756
        bsfc= bsfc->next;
757
    }
758

    
759
    ret= av_interleaved_write_frame(s, pkt);
760
    if(ret < 0){
761
        print_error("av_interleaved_write_frame()", ret);
762
        ffmpeg_exit(1);
763
    }
764
}
765

    
766
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
767

    
768
static void do_audio_out(AVFormatContext *s,
769
                         AVOutputStream *ost,
770
                         AVInputStream *ist,
771
                         unsigned char *buf, int size)
772
{
773
    uint8_t *buftmp;
774
    int64_t audio_out_size, audio_buf_size;
775
    int64_t allocated_for_size= size;
776

    
777
    int size_out, frame_bytes, ret;
778
    AVCodecContext *enc= ost->st->codec;
779
    AVCodecContext *dec= ist->st->codec;
780
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
781
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
782
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
783

    
784
need_realloc:
785
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
786
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
787
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
788
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
789
    audio_buf_size*= osize*enc->channels;
790

    
791
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
792
    if(coded_bps > 8*osize)
793
        audio_out_size= audio_out_size * coded_bps / (8*osize);
794
    audio_out_size += FF_MIN_BUFFER_SIZE;
795

    
796
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
797
        fprintf(stderr, "Buffer sizes too large\n");
798
        ffmpeg_exit(1);
799
    }
800

    
801
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
802
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
803
    if (!audio_buf || !audio_out){
804
        fprintf(stderr, "Out of memory in do_audio_out\n");
805
        ffmpeg_exit(1);
806
    }
807

    
808
    if (enc->channels != dec->channels)
809
        ost->audio_resample = 1;
810

    
811
    if (ost->audio_resample && !ost->resample) {
812
        if (dec->sample_fmt != SAMPLE_FMT_S16)
813
            fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
814
        ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
815
                                               enc->sample_rate, dec->sample_rate,
816
                                               enc->sample_fmt,  dec->sample_fmt,
817
                                               16, 10, 0, 0.8);
818
        if (!ost->resample) {
819
            fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
820
                    dec->channels, dec->sample_rate,
821
                    enc->channels, enc->sample_rate);
822
            ffmpeg_exit(1);
823
        }
824
    }
825

    
826
#define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
827
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
828
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
829
        if (ost->reformat_ctx)
830
            av_audio_convert_free(ost->reformat_ctx);
831
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
832
                                                   dec->sample_fmt, 1, NULL, 0);
833
        if (!ost->reformat_ctx) {
834
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
835
                av_get_sample_fmt_name(dec->sample_fmt),
836
                av_get_sample_fmt_name(enc->sample_fmt));
837
            ffmpeg_exit(1);
838
        }
839
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
840
    }
841

    
842
    if(audio_sync_method){
843
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
844
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
845
        double idelta= delta*dec->sample_rate / enc->sample_rate;
846
        int byte_delta= ((int)idelta)*2*dec->channels;
847

    
848
        //FIXME resample delay
849
        if(fabs(delta) > 50){
850
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
851
                if(byte_delta < 0){
852
                    byte_delta= FFMAX(byte_delta, -size);
853
                    size += byte_delta;
854
                    buf  -= byte_delta;
855
                    if(verbose > 2)
856
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
857
                    if(!size)
858
                        return;
859
                    ist->is_start=0;
860
                }else{
861
                    static uint8_t *input_tmp= NULL;
862
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
863

    
864
                    if(byte_delta > allocated_for_size - size){
865
                        allocated_for_size= byte_delta + (int64_t)size;
866
                        goto need_realloc;
867
                    }
868
                    ist->is_start=0;
869

    
870
                    memset(input_tmp, 0, byte_delta);
871
                    memcpy(input_tmp + byte_delta, buf, size);
872
                    buf= input_tmp;
873
                    size += byte_delta;
874
                    if(verbose > 2)
875
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
876
                }
877
            }else if(audio_sync_method>1){
878
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
879
                av_assert0(ost->audio_resample);
880
                if(verbose > 2)
881
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
882
//                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));
883
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
884
            }
885
        }
886
    }else
887
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
888
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
889

    
890
    if (ost->audio_resample) {
891
        buftmp = audio_buf;
892
        size_out = audio_resample(ost->resample,
893
                                  (short *)buftmp, (short *)buf,
894
                                  size / (dec->channels * isize));
895
        size_out = size_out * enc->channels * osize;
896
    } else {
897
        buftmp = buf;
898
        size_out = size;
899
    }
900

    
901
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
902
        const void *ibuf[6]= {buftmp};
903
        void *obuf[6]= {audio_buf};
904
        int istride[6]= {isize};
905
        int ostride[6]= {osize};
906
        int len= size_out/istride[0];
907
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
908
            printf("av_audio_convert() failed\n");
909
            if (exit_on_error)
910
                ffmpeg_exit(1);
911
            return;
912
        }
913
        buftmp = audio_buf;
914
        size_out = len*osize;
915
    }
916

    
917
    /* now encode as many frames as possible */
918
    if (enc->frame_size > 1) {
919
        /* output resampled raw samples */
920
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
921
            fprintf(stderr, "av_fifo_realloc2() failed\n");
922
            ffmpeg_exit(1);
923
        }
924
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
925

    
926
        frame_bytes = enc->frame_size * osize * enc->channels;
927

    
928
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
929
            AVPacket pkt;
930
            av_init_packet(&pkt);
931

    
932
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
933

    
934
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
935

    
936
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
937
                                       (short *)audio_buf);
938
            if (ret < 0) {
939
                fprintf(stderr, "Audio encoding failed\n");
940
                ffmpeg_exit(1);
941
            }
942
            audio_size += ret;
943
            pkt.stream_index= ost->index;
944
            pkt.data= audio_out;
945
            pkt.size= ret;
946
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
947
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
948
            pkt.flags |= AV_PKT_FLAG_KEY;
949
            write_frame(s, &pkt, enc, ost->bitstream_filters);
950

    
951
            ost->sync_opts += enc->frame_size;
952
        }
953
    } else {
954
        AVPacket pkt;
955
        av_init_packet(&pkt);
956

    
957
        ost->sync_opts += size_out / (osize * enc->channels);
958

    
959
        /* output a pcm frame */
960
        /* determine the size of the coded buffer */
961
        size_out /= osize;
962
        if (coded_bps)
963
            size_out = size_out*coded_bps/8;
964

    
965
        if(size_out > audio_out_size){
966
            fprintf(stderr, "Internal error, buffer size too small\n");
967
            ffmpeg_exit(1);
968
        }
969

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

    
988
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
989
{
990
    AVCodecContext *dec;
991
    AVPicture *picture2;
992
    AVPicture picture_tmp;
993
    uint8_t *buf = 0;
994

    
995
    dec = ist->st->codec;
996

    
997
    /* deinterlace : must be done before any resize */
998
    if (do_deinterlace) {
999
        int size;
1000

    
1001
        /* create temporary picture */
1002
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1003
        buf = av_malloc(size);
1004
        if (!buf)
1005
            return;
1006

    
1007
        picture2 = &picture_tmp;
1008
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1009

    
1010
        if(avpicture_deinterlace(picture2, picture,
1011
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1012
            /* if error, do not deinterlace */
1013
            fprintf(stderr, "Deinterlacing failed\n");
1014
            av_free(buf);
1015
            buf = NULL;
1016
            picture2 = picture;
1017
        }
1018
    } else {
1019
        picture2 = picture;
1020
    }
1021

    
1022
    if (picture != picture2)
1023
        *picture = *picture2;
1024
    *bufp = buf;
1025
}
1026

    
1027
/* we begin to correct av delay at this threshold */
1028
#define AV_DELAY_MAX 0.100
1029

    
1030
static void do_subtitle_out(AVFormatContext *s,
1031
                            AVOutputStream *ost,
1032
                            AVInputStream *ist,
1033
                            AVSubtitle *sub,
1034
                            int64_t pts)
1035
{
1036
    static uint8_t *subtitle_out = NULL;
1037
    int subtitle_out_max_size = 1024 * 1024;
1038
    int subtitle_out_size, nb, i;
1039
    AVCodecContext *enc;
1040
    AVPacket pkt;
1041

    
1042
    if (pts == AV_NOPTS_VALUE) {
1043
        fprintf(stderr, "Subtitle packets must have a pts\n");
1044
        if (exit_on_error)
1045
            ffmpeg_exit(1);
1046
        return;
1047
    }
1048

    
1049
    enc = ost->st->codec;
1050

    
1051
    if (!subtitle_out) {
1052
        subtitle_out = av_malloc(subtitle_out_max_size);
1053
    }
1054

    
1055
    /* Note: DVB subtitle need one packet to draw them and one other
1056
       packet to clear them */
1057
    /* XXX: signal it in the codec context ? */
1058
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1059
        nb = 2;
1060
    else
1061
        nb = 1;
1062

    
1063
    for(i = 0; i < nb; i++) {
1064
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1065
        // start_display_time is required to be 0
1066
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1067
        sub->end_display_time -= sub->start_display_time;
1068
        sub->start_display_time = 0;
1069
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1070
                                                    subtitle_out_max_size, sub);
1071
        if (subtitle_out_size < 0) {
1072
            fprintf(stderr, "Subtitle encoding failed\n");
1073
            ffmpeg_exit(1);
1074
        }
1075

    
1076
        av_init_packet(&pkt);
1077
        pkt.stream_index = ost->index;
1078
        pkt.data = subtitle_out;
1079
        pkt.size = subtitle_out_size;
1080
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1081
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1082
            /* XXX: the pts correction is handled here. Maybe handling
1083
               it in the codec would be better */
1084
            if (i == 0)
1085
                pkt.pts += 90 * sub->start_display_time;
1086
            else
1087
                pkt.pts += 90 * sub->end_display_time;
1088
        }
1089
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1090
    }
1091
}
1092

    
1093
static int bit_buffer_size= 1024*256;
1094
static uint8_t *bit_buffer= NULL;
1095

    
1096
static void do_video_out(AVFormatContext *s,
1097
                         AVOutputStream *ost,
1098
                         AVInputStream *ist,
1099
                         AVFrame *in_picture,
1100
                         int *frame_size)
1101
{
1102
    int nb_frames, i, ret;
1103
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1104
    AVCodecContext *enc, *dec;
1105
    double sync_ipts;
1106

    
1107
    enc = ost->st->codec;
1108
    dec = ist->st->codec;
1109

    
1110
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1111

    
1112
    /* by default, we output a single frame */
1113
    nb_frames = 1;
1114

    
1115
    *frame_size = 0;
1116

    
1117
    if(video_sync_method){
1118
        double vdelta = sync_ipts - ost->sync_opts;
1119
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1120
        if (vdelta < -1.1)
1121
            nb_frames = 0;
1122
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1123
            if(vdelta<=-0.6){
1124
                nb_frames=0;
1125
            }else if(vdelta>0.6)
1126
            ost->sync_opts= lrintf(sync_ipts);
1127
        }else if (vdelta > 1.1)
1128
            nb_frames = lrintf(vdelta);
1129
//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);
1130
        if (nb_frames == 0){
1131
            ++nb_frames_drop;
1132
            if (verbose>2)
1133
                fprintf(stderr, "*** drop!\n");
1134
        }else if (nb_frames > 1) {
1135
            nb_frames_dup += nb_frames - 1;
1136
            if (verbose>2)
1137
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1138
        }
1139
    }else
1140
        ost->sync_opts= lrintf(sync_ipts);
1141

    
1142
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1143
    if (nb_frames <= 0)
1144
        return;
1145

    
1146
    formatted_picture = in_picture;
1147
    final_picture = formatted_picture;
1148
    padding_src = formatted_picture;
1149
    resampling_dst = &ost->pict_tmp;
1150

    
1151
    if (   ost->resample_height != ist->st->codec->height
1152
        || ost->resample_width  != ist->st->codec->width
1153
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1154

    
1155
        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));
1156
        if(!ost->video_resample)
1157
            ffmpeg_exit(1);
1158
    }
1159

    
1160
#if !CONFIG_AVFILTER
1161
    if (ost->video_resample) {
1162
        padding_src = NULL;
1163
        final_picture = &ost->pict_tmp;
1164
        if(  ost->resample_height != ist->st->codec->height
1165
          || ost->resample_width  != ist->st->codec->width
1166
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1167

    
1168
            /* initialize a new scaler context */
1169
            sws_freeContext(ost->img_resample_ctx);
1170
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1171
            ost->img_resample_ctx = sws_getContext(
1172
                ist->st->codec->width,
1173
                ist->st->codec->height,
1174
                ist->st->codec->pix_fmt,
1175
                ost->st->codec->width,
1176
                ost->st->codec->height,
1177
                ost->st->codec->pix_fmt,
1178
                sws_flags, NULL, NULL, NULL);
1179
            if (ost->img_resample_ctx == NULL) {
1180
                fprintf(stderr, "Cannot get resampling context\n");
1181
                ffmpeg_exit(1);
1182
            }
1183
        }
1184
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1185
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1186
    }
1187
#endif
1188

    
1189
    /* duplicates frame if needed */
1190
    for(i=0;i<nb_frames;i++) {
1191
        AVPacket pkt;
1192
        av_init_packet(&pkt);
1193
        pkt.stream_index= ost->index;
1194

    
1195
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1196
            /* raw pictures are written as AVPicture structure to
1197
               avoid any copies. We support temorarily the older
1198
               method. */
1199
            AVFrame* old_frame = enc->coded_frame;
1200
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1201
            pkt.data= (uint8_t *)final_picture;
1202
            pkt.size=  sizeof(AVPicture);
1203
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1204
            pkt.flags |= AV_PKT_FLAG_KEY;
1205

    
1206
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1207
            enc->coded_frame = old_frame;
1208
        } else {
1209
            AVFrame big_picture;
1210

    
1211
            big_picture= *final_picture;
1212
            /* better than nothing: use input picture interlaced
1213
               settings */
1214
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1215
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1216
                if(top_field_first == -1)
1217
                    big_picture.top_field_first = in_picture->top_field_first;
1218
                else
1219
                    big_picture.top_field_first = top_field_first;
1220
            }
1221

    
1222
            /* handles sameq here. This is not correct because it may
1223
               not be a global option */
1224
            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1225
            if(!me_threshold)
1226
                big_picture.pict_type = 0;
1227
//            big_picture.pts = AV_NOPTS_VALUE;
1228
            big_picture.pts= ost->sync_opts;
1229
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1230
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1231
            if (ost->forced_kf_index < ost->forced_kf_count &&
1232
                big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1233
                big_picture.pict_type = FF_I_TYPE;
1234
                ost->forced_kf_index++;
1235
            }
1236
            ret = avcodec_encode_video(enc,
1237
                                       bit_buffer, bit_buffer_size,
1238
                                       &big_picture);
1239
            if (ret < 0) {
1240
                fprintf(stderr, "Video encoding failed\n");
1241
                ffmpeg_exit(1);
1242
            }
1243

    
1244
            if(ret>0){
1245
                pkt.data= bit_buffer;
1246
                pkt.size= ret;
1247
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1248
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1249
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1250
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1251
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1252

    
1253
                if(enc->coded_frame->key_frame)
1254
                    pkt.flags |= AV_PKT_FLAG_KEY;
1255
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1256
                *frame_size = ret;
1257
                video_size += ret;
1258
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1259
                //        enc->frame_number-1, ret, enc->pict_type);
1260
                /* if two pass, output log */
1261
                if (ost->logfile && enc->stats_out) {
1262
                    fprintf(ost->logfile, "%s", enc->stats_out);
1263
                }
1264
            }
1265
        }
1266
        ost->sync_opts++;
1267
        ost->frame_number++;
1268
    }
1269
}
1270

    
1271
static double psnr(double d){
1272
    return -10.0*log(d)/log(10.0);
1273
}
1274

    
1275
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1276
                           int frame_size)
1277
{
1278
    AVCodecContext *enc;
1279
    int frame_number;
1280
    double ti1, bitrate, avg_bitrate;
1281

    
1282
    /* this is executed just the first time do_video_stats is called */
1283
    if (!vstats_file) {
1284
        vstats_file = fopen(vstats_filename, "w");
1285
        if (!vstats_file) {
1286
            perror("fopen");
1287
            ffmpeg_exit(1);
1288
        }
1289
    }
1290

    
1291
    enc = ost->st->codec;
1292
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1293
        frame_number = ost->frame_number;
1294
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1295
        if (enc->flags&CODEC_FLAG_PSNR)
1296
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1297

    
1298
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1299
        /* compute pts value */
1300
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1301
        if (ti1 < 0.01)
1302
            ti1 = 0.01;
1303

    
1304
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1305
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1306
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1307
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1308
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1309
    }
1310
}
1311

    
1312
static void print_report(AVFormatContext **output_files,
1313
                         AVOutputStream **ost_table, int nb_ostreams,
1314
                         int is_last_report)
1315
{
1316
    char buf[1024];
1317
    AVOutputStream *ost;
1318
    AVFormatContext *oc;
1319
    int64_t total_size;
1320
    AVCodecContext *enc;
1321
    int frame_number, vid, i;
1322
    double bitrate, ti1, pts;
1323
    static int64_t last_time = -1;
1324
    static int qp_histogram[52];
1325

    
1326
    if (!is_last_report) {
1327
        int64_t cur_time;
1328
        /* display the report every 0.5 seconds */
1329
        cur_time = av_gettime();
1330
        if (last_time == -1) {
1331
            last_time = cur_time;
1332
            return;
1333
        }
1334
        if ((cur_time - last_time) < 500000)
1335
            return;
1336
        last_time = cur_time;
1337
    }
1338

    
1339

    
1340
    oc = output_files[0];
1341

    
1342
    total_size = url_fsize(oc->pb);
1343
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1344
        total_size= url_ftell(oc->pb);
1345

    
1346
    buf[0] = '\0';
1347
    ti1 = 1e10;
1348
    vid = 0;
1349
    for(i=0;i<nb_ostreams;i++) {
1350
        ost = ost_table[i];
1351
        enc = ost->st->codec;
1352
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1353
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1354
                     !ost->st->stream_copy ?
1355
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1356
        }
1357
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1358
            float t = (av_gettime()-timer_start) / 1000000.0;
1359

    
1360
            frame_number = ost->frame_number;
1361
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1362
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1363
                     !ost->st->stream_copy ?
1364
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1365
            if(is_last_report)
1366
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1367
            if(qp_hist){
1368
                int j;
1369
                int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1370
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1371
                    qp_histogram[qp]++;
1372
                for(j=0; j<32; j++)
1373
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1374
            }
1375
            if (enc->flags&CODEC_FLAG_PSNR){
1376
                int j;
1377
                double error, error_sum=0;
1378
                double scale, scale_sum=0;
1379
                char type[3]= {'Y','U','V'};
1380
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1381
                for(j=0; j<3; j++){
1382
                    if(is_last_report){
1383
                        error= enc->error[j];
1384
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1385
                    }else{
1386
                        error= enc->coded_frame->error[j];
1387
                        scale= enc->width*enc->height*255.0*255.0;
1388
                    }
1389
                    if(j) scale/=4;
1390
                    error_sum += error;
1391
                    scale_sum += scale;
1392
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1393
                }
1394
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1395
            }
1396
            vid = 1;
1397
        }
1398
        /* compute min output value */
1399
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1400
        if ((pts < ti1) && (pts > 0))
1401
            ti1 = pts;
1402
    }
1403
    if (ti1 < 0.01)
1404
        ti1 = 0.01;
1405

    
1406
    if (verbose || is_last_report) {
1407
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1408

    
1409
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1410
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1411
            (double)total_size / 1024, ti1, bitrate);
1412

    
1413
        if (nb_frames_dup || nb_frames_drop)
1414
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1415
                  nb_frames_dup, nb_frames_drop);
1416

    
1417
        if (verbose >= 0)
1418
            fprintf(stderr, "%s    \r", buf);
1419

    
1420
        fflush(stderr);
1421
    }
1422

    
1423
    if (is_last_report && verbose >= 0){
1424
        int64_t raw= audio_size + video_size + extra_size;
1425
        fprintf(stderr, "\n");
1426
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1427
                video_size/1024.0,
1428
                audio_size/1024.0,
1429
                extra_size/1024.0,
1430
                100.0*(total_size - raw)/raw
1431
        );
1432
    }
1433
}
1434

    
1435
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1436
static int output_packet(AVInputStream *ist, int ist_index,
1437
                         AVOutputStream **ost_table, int nb_ostreams,
1438
                         const AVPacket *pkt)
1439
{
1440
    AVFormatContext *os;
1441
    AVOutputStream *ost;
1442
    int ret, i;
1443
    int got_picture;
1444
    AVFrame picture;
1445
    void *buffer_to_free;
1446
    static unsigned int samples_size= 0;
1447
    AVSubtitle subtitle, *subtitle_to_free;
1448
    int64_t pkt_pts = AV_NOPTS_VALUE;
1449
#if CONFIG_AVFILTER
1450
    int frame_available;
1451
#endif
1452

    
1453
    AVPacket avpkt;
1454
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1455

    
1456
    if(ist->next_pts == AV_NOPTS_VALUE)
1457
        ist->next_pts= ist->pts;
1458

    
1459
    if (pkt == NULL) {
1460
        /* EOF handling */
1461
        av_init_packet(&avpkt);
1462
        avpkt.data = NULL;
1463
        avpkt.size = 0;
1464
        goto handle_eof;
1465
    } else {
1466
        avpkt = *pkt;
1467
    }
1468

    
1469
    if(pkt->dts != AV_NOPTS_VALUE)
1470
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1471
    if(pkt->pts != AV_NOPTS_VALUE)
1472
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1473

    
1474
    //while we have more to decode or while the decoder did output something on EOF
1475
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1476
        uint8_t *data_buf, *decoded_data_buf;
1477
        int data_size, decoded_data_size;
1478
    handle_eof:
1479
        ist->pts= ist->next_pts;
1480

    
1481
        if(avpkt.size && avpkt.size != pkt->size &&
1482
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1483
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1484
            ist->showed_multi_packet_warning=1;
1485
        }
1486

    
1487
        /* decode the packet if needed */
1488
        decoded_data_buf = NULL; /* fail safe */
1489
        decoded_data_size= 0;
1490
        data_buf  = avpkt.data;
1491
        data_size = avpkt.size;
1492
        subtitle_to_free = NULL;
1493
        if (ist->decoding_needed) {
1494
            switch(ist->st->codec->codec_type) {
1495
            case AVMEDIA_TYPE_AUDIO:{
1496
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1497
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1498
                    av_free(samples);
1499
                    samples= av_malloc(samples_size);
1500
                }
1501
                decoded_data_size= samples_size;
1502
                    /* XXX: could avoid copy if PCM 16 bits with same
1503
                       endianness as CPU */
1504
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1505
                                            &avpkt);
1506
                if (ret < 0)
1507
                    goto fail_decode;
1508
                avpkt.data += ret;
1509
                avpkt.size -= ret;
1510
                data_size   = ret;
1511
                /* Some bug in mpeg audio decoder gives */
1512
                /* decoded_data_size < 0, it seems they are overflows */
1513
                if (decoded_data_size <= 0) {
1514
                    /* no audio frame */
1515
                    continue;
1516
                }
1517
                decoded_data_buf = (uint8_t *)samples;
1518
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1519
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1520
                break;}
1521
            case AVMEDIA_TYPE_VIDEO:
1522
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1523
                    /* XXX: allocate picture correctly */
1524
                    avcodec_get_frame_defaults(&picture);
1525
                    ist->st->codec->reordered_opaque = pkt_pts;
1526
                    pkt_pts = AV_NOPTS_VALUE;
1527

    
1528
                    ret = avcodec_decode_video2(ist->st->codec,
1529
                                                &picture, &got_picture, &avpkt);
1530
                    ist->st->quality= picture.quality;
1531
                    if (ret < 0)
1532
                        goto fail_decode;
1533
                    if (!got_picture) {
1534
                        /* no picture yet */
1535
                        goto discard_packet;
1536
                    }
1537
                    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.reordered_opaque, ist->pts);
1538
                    if (ist->st->codec->time_base.num != 0) {
1539
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1540
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1541
                                          ist->st->codec->time_base.num * ticks) /
1542
                            ist->st->codec->time_base.den;
1543
                    }
1544
                    avpkt.size = 0;
1545
                    break;
1546
            case AVMEDIA_TYPE_SUBTITLE:
1547
                ret = avcodec_decode_subtitle2(ist->st->codec,
1548
                                               &subtitle, &got_picture, &avpkt);
1549
                if (ret < 0)
1550
                    goto fail_decode;
1551
                if (!got_picture) {
1552
                    goto discard_packet;
1553
                }
1554
                subtitle_to_free = &subtitle;
1555
                avpkt.size = 0;
1556
                break;
1557
            default:
1558
                goto fail_decode;
1559
            }
1560
        } else {
1561
            switch(ist->st->codec->codec_type) {
1562
            case AVMEDIA_TYPE_AUDIO:
1563
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1564
                    ist->st->codec->sample_rate;
1565
                break;
1566
            case AVMEDIA_TYPE_VIDEO:
1567
                if (ist->st->codec->time_base.num != 0) {
1568
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1569
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1570
                                      ist->st->codec->time_base.num * ticks) /
1571
                        ist->st->codec->time_base.den;
1572
                }
1573
                break;
1574
            }
1575
            ret = avpkt.size;
1576
            avpkt.size = 0;
1577
        }
1578

    
1579
        buffer_to_free = NULL;
1580
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1581
            pre_process_video_frame(ist, (AVPicture *)&picture,
1582
                                    &buffer_to_free);
1583
        }
1584

    
1585
#if CONFIG_AVFILTER
1586
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1587
            // add it to be filtered
1588
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1589
                                     ist->pts,
1590
                                     ist->st->codec->sample_aspect_ratio);
1591
        }
1592
#endif
1593

    
1594
        // preprocess audio (volume)
1595
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1596
            if (audio_volume != 256) {
1597
                short *volp;
1598
                volp = samples;
1599
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1600
                    int v = ((*volp) * audio_volume + 128) >> 8;
1601
                    if (v < -32768) v = -32768;
1602
                    if (v >  32767) v = 32767;
1603
                    *volp++ = v;
1604
                }
1605
            }
1606
        }
1607

    
1608
        /* frame rate emulation */
1609
        if (rate_emu) {
1610
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1611
            int64_t now = av_gettime() - ist->start;
1612
            if (pts > now)
1613
                usleep(pts - now);
1614
        }
1615
#if CONFIG_AVFILTER
1616
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1617
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1618
#endif
1619
        /* if output time reached then transcode raw format,
1620
           encode packets and output them */
1621
        if (start_time == 0 || ist->pts >= start_time)
1622
#if CONFIG_AVFILTER
1623
        while (frame_available) {
1624
            AVRational ist_pts_tb;
1625
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1626
                get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1627
            if (ist->picref)
1628
                ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1629
#endif
1630
            for(i=0;i<nb_ostreams;i++) {
1631
                int frame_size;
1632

    
1633
                ost = ost_table[i];
1634
                if (ost->source_index == ist_index) {
1635
                    os = output_files[ost->file_index];
1636

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

    
1640
                    if (ost->encoding_needed) {
1641
                        av_assert0(ist->decoding_needed);
1642
                        switch(ost->st->codec->codec_type) {
1643
                        case AVMEDIA_TYPE_AUDIO:
1644
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1645
                            break;
1646
                        case AVMEDIA_TYPE_VIDEO:
1647
#if CONFIG_AVFILTER
1648
                            if (ist->picref->video)
1649
                                ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1650
#endif
1651
                            do_video_out(os, ost, ist, &picture, &frame_size);
1652
                            if (vstats_filename && frame_size)
1653
                                do_video_stats(os, ost, frame_size);
1654
                            break;
1655
                        case AVMEDIA_TYPE_SUBTITLE:
1656
                            do_subtitle_out(os, ost, ist, &subtitle,
1657
                                            pkt->pts);
1658
                            break;
1659
                        default:
1660
                            abort();
1661
                        }
1662
                    } else {
1663
                        AVFrame avframe; //FIXME/XXX remove this
1664
                        AVPacket opkt;
1665
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1666

    
1667
                        av_init_packet(&opkt);
1668

    
1669
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1670
                            continue;
1671

    
1672
                        /* no reencoding needed : output the packet directly */
1673
                        /* force the input stream PTS */
1674

    
1675
                        avcodec_get_frame_defaults(&avframe);
1676
                        ost->st->codec->coded_frame= &avframe;
1677
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1678

    
1679
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1680
                            audio_size += data_size;
1681
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1682
                            video_size += data_size;
1683
                            ost->sync_opts++;
1684
                        }
1685

    
1686
                        opkt.stream_index= ost->index;
1687
                        if(pkt->pts != AV_NOPTS_VALUE)
1688
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1689
                        else
1690
                            opkt.pts= AV_NOPTS_VALUE;
1691

    
1692
                        if (pkt->dts == AV_NOPTS_VALUE)
1693
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1694
                        else
1695
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1696
                        opkt.dts -= ost_tb_start_time;
1697

    
1698
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1699
                        opkt.flags= pkt->flags;
1700

    
1701
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1702
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1703
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1704
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1705
                           ) {
1706
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1707
                                opkt.destruct= av_destruct_packet;
1708
                        } else {
1709
                            opkt.data = data_buf;
1710
                            opkt.size = data_size;
1711
                        }
1712

    
1713
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1714
                        ost->st->codec->frame_number++;
1715
                        ost->frame_number++;
1716
                        av_free_packet(&opkt);
1717
                    }
1718
                }
1719
            }
1720

    
1721
#if CONFIG_AVFILTER
1722
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1723
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1724
            if(ist->picref)
1725
                avfilter_unref_buffer(ist->picref);
1726
        }
1727
#endif
1728
        av_free(buffer_to_free);
1729
        /* XXX: allocate the subtitles in the codec ? */
1730
        if (subtitle_to_free) {
1731
            if (subtitle_to_free->rects != NULL) {
1732
                for (i = 0; i < subtitle_to_free->num_rects; i++) {
1733
                    av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1734
                    av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1735
                    av_freep(&subtitle_to_free->rects[i]);
1736
                }
1737
                av_freep(&subtitle_to_free->rects);
1738
            }
1739
            subtitle_to_free->num_rects = 0;
1740
            subtitle_to_free = NULL;
1741
        }
1742
    }
1743
 discard_packet:
1744
    if (pkt == NULL) {
1745
        /* EOF handling */
1746

    
1747
        for(i=0;i<nb_ostreams;i++) {
1748
            ost = ost_table[i];
1749
            if (ost->source_index == ist_index) {
1750
                AVCodecContext *enc= ost->st->codec;
1751
                os = output_files[ost->file_index];
1752

    
1753
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1754
                    continue;
1755
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1756
                    continue;
1757

    
1758
                if (ost->encoding_needed) {
1759
                    for(;;) {
1760
                        AVPacket pkt;
1761
                        int fifo_bytes;
1762
                        av_init_packet(&pkt);
1763
                        pkt.stream_index= ost->index;
1764

    
1765
                        switch(ost->st->codec->codec_type) {
1766
                        case AVMEDIA_TYPE_AUDIO:
1767
                            fifo_bytes = av_fifo_size(ost->fifo);
1768
                            ret = 0;
1769
                            /* encode any samples remaining in fifo */
1770
                            if (fifo_bytes > 0) {
1771
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1772
                                int fs_tmp = enc->frame_size;
1773

    
1774
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1775
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1776
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1777
                                } else { /* pad */
1778
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1779
                                    if (allocated_audio_buf_size < frame_bytes)
1780
                                        ffmpeg_exit(1);
1781
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1782
                                }
1783

    
1784
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1785
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1786
                                                          ost->st->time_base.num, enc->sample_rate);
1787
                                enc->frame_size = fs_tmp;
1788
                            }
1789
                            if(ret <= 0) {
1790
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1791
                            }
1792
                            if (ret < 0) {
1793
                                fprintf(stderr, "Audio encoding failed\n");
1794
                                ffmpeg_exit(1);
1795
                            }
1796
                            audio_size += ret;
1797
                            pkt.flags |= AV_PKT_FLAG_KEY;
1798
                            break;
1799
                        case AVMEDIA_TYPE_VIDEO:
1800
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1801
                            if (ret < 0) {
1802
                                fprintf(stderr, "Video encoding failed\n");
1803
                                ffmpeg_exit(1);
1804
                            }
1805
                            video_size += ret;
1806
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1807
                                pkt.flags |= AV_PKT_FLAG_KEY;
1808
                            if (ost->logfile && enc->stats_out) {
1809
                                fprintf(ost->logfile, "%s", enc->stats_out);
1810
                            }
1811
                            break;
1812
                        default:
1813
                            ret=-1;
1814
                        }
1815

    
1816
                        if(ret<=0)
1817
                            break;
1818
                        pkt.data= bit_buffer;
1819
                        pkt.size= ret;
1820
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1821
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1822
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1823
                    }
1824
                }
1825
            }
1826
        }
1827
    }
1828

    
1829
    return 0;
1830
 fail_decode:
1831
    return -1;
1832
}
1833

    
1834
static void print_sdp(AVFormatContext **avc, int n)
1835
{
1836
    char sdp[2048];
1837

    
1838
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1839
    printf("SDP:\n%s\n", sdp);
1840
    fflush(stdout);
1841
}
1842

    
1843
static int copy_chapters(int infile, int outfile)
1844
{
1845
    AVFormatContext *is = input_files[infile];
1846
    AVFormatContext *os = output_files[outfile];
1847
    int i;
1848

    
1849
    for (i = 0; i < is->nb_chapters; i++) {
1850
        AVChapter *in_ch = is->chapters[i], *out_ch;
1851
        AVMetadataTag *t = NULL;
1852
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1853
                                      AV_TIME_BASE_Q, in_ch->time_base);
1854
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1855
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1856

    
1857

    
1858
        if (in_ch->end < ts_off)
1859
            continue;
1860
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1861
            break;
1862

    
1863
        out_ch = av_mallocz(sizeof(AVChapter));
1864
        if (!out_ch)
1865
            return AVERROR(ENOMEM);
1866

    
1867
        out_ch->id        = in_ch->id;
1868
        out_ch->time_base = in_ch->time_base;
1869
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1870
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1871

    
1872
        if (metadata_chapters_autocopy)
1873
            while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1874
                av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1875

    
1876
        os->nb_chapters++;
1877
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1878
        if (!os->chapters)
1879
            return AVERROR(ENOMEM);
1880
        os->chapters[os->nb_chapters - 1] = out_ch;
1881
    }
1882
    return 0;
1883
}
1884

    
1885
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1886
                                    AVCodecContext *avctx)
1887
{
1888
    char *p;
1889
    int n = 1, i;
1890
    int64_t t;
1891

    
1892
    for (p = kf; *p; p++)
1893
        if (*p == ',')
1894
            n++;
1895
    ost->forced_kf_count = n;
1896
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1897
    if (!ost->forced_kf_pts) {
1898
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1899
        ffmpeg_exit(1);
1900
    }
1901
    for (i = 0; i < n; i++) {
1902
        p = i ? strchr(p, ',') + 1 : kf;
1903
        t = parse_time_or_die("force_key_frames", p, 1);
1904
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1905
    }
1906
}
1907

    
1908
/*
1909
 * The following code is the main loop of the file converter
1910
 */
1911
static int transcode(AVFormatContext **output_files,
1912
                     int nb_output_files,
1913
                     AVFormatContext **input_files,
1914
                     int nb_input_files,
1915
                     AVStreamMap *stream_maps, int nb_stream_maps)
1916
{
1917
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1918
    AVFormatContext *is, *os;
1919
    AVCodecContext *codec, *icodec;
1920
    AVOutputStream *ost, **ost_table = NULL;
1921
    AVInputStream *ist, **ist_table = NULL;
1922
    AVInputFile *file_table;
1923
    char error[1024];
1924
    int key;
1925
    int want_sdp = 1;
1926
    uint8_t no_packet[MAX_FILES]={0};
1927
    int no_packet_count=0;
1928

    
1929
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1930
    if (!file_table)
1931
        goto fail;
1932

    
1933
    /* input stream init */
1934
    j = 0;
1935
    for(i=0;i<nb_input_files;i++) {
1936
        is = input_files[i];
1937
        file_table[i].ist_index = j;
1938
        file_table[i].nb_streams = is->nb_streams;
1939
        j += is->nb_streams;
1940
    }
1941
    nb_istreams = j;
1942

    
1943
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1944
    if (!ist_table)
1945
        goto fail;
1946

    
1947
    for(i=0;i<nb_istreams;i++) {
1948
        ist = av_mallocz(sizeof(AVInputStream));
1949
        if (!ist)
1950
            goto fail;
1951
        ist_table[i] = ist;
1952
    }
1953
    j = 0;
1954
    for(i=0;i<nb_input_files;i++) {
1955
        is = input_files[i];
1956
        for(k=0;k<is->nb_streams;k++) {
1957
            ist = ist_table[j++];
1958
            ist->st = is->streams[k];
1959
            ist->file_index = i;
1960
            ist->index = k;
1961
            ist->discard = 1; /* the stream is discarded by default
1962
                                 (changed later) */
1963

    
1964
            if (rate_emu) {
1965
                ist->start = av_gettime();
1966
            }
1967
        }
1968
    }
1969

    
1970
    /* output stream init */
1971
    nb_ostreams = 0;
1972
    for(i=0;i<nb_output_files;i++) {
1973
        os = output_files[i];
1974
        if (!os->nb_streams) {
1975
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1976
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1977
            ret = AVERROR(EINVAL);
1978
            goto fail;
1979
        }
1980
        nb_ostreams += os->nb_streams;
1981
    }
1982
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1983
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
1984
        ret = AVERROR(EINVAL);
1985
        goto fail;
1986
    }
1987

    
1988
    /* Sanity check the mapping args -- do the input files & streams exist? */
1989
    for(i=0;i<nb_stream_maps;i++) {
1990
        int fi = stream_maps[i].file_index;
1991
        int si = stream_maps[i].stream_index;
1992

    
1993
        if (fi < 0 || fi > nb_input_files - 1 ||
1994
            si < 0 || si > file_table[fi].nb_streams - 1) {
1995
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1996
            ret = AVERROR(EINVAL);
1997
            goto fail;
1998
        }
1999
        fi = stream_maps[i].sync_file_index;
2000
        si = stream_maps[i].sync_stream_index;
2001
        if (fi < 0 || fi > nb_input_files - 1 ||
2002
            si < 0 || si > file_table[fi].nb_streams - 1) {
2003
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2004
            ret = AVERROR(EINVAL);
2005
            goto fail;
2006
        }
2007
    }
2008

    
2009
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2010
    if (!ost_table)
2011
        goto fail;
2012
    n = 0;
2013
    for(k=0;k<nb_output_files;k++) {
2014
        os = output_files[k];
2015
        for(i=0;i<os->nb_streams;i++,n++) {
2016
            int found;
2017
            ost = ost_table[n] = output_streams_for_file[k][i];
2018
            ost->st = os->streams[i];
2019
            if (nb_stream_maps > 0) {
2020
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2021
                    stream_maps[n].stream_index;
2022

    
2023
                /* Sanity check that the stream types match */
2024
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2025
                    int i= ost->file_index;
2026
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
2027
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2028
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2029
                        ost->file_index, ost->index);
2030
                    ffmpeg_exit(1);
2031
                }
2032

    
2033
            } else {
2034
                int best_nb_frames=-1;
2035
                /* get corresponding input stream index : we select the first one with the right type */
2036
                found = 0;
2037
                for(j=0;j<nb_istreams;j++) {
2038
                    int skip=0;
2039
                    ist = ist_table[j];
2040
                    if(opt_programid){
2041
                        int pi,si;
2042
                        AVFormatContext *f= input_files[ ist->file_index ];
2043
                        skip=1;
2044
                        for(pi=0; pi<f->nb_programs; pi++){
2045
                            AVProgram *p= f->programs[pi];
2046
                            if(p->id == opt_programid)
2047
                                for(si=0; si<p->nb_stream_indexes; si++){
2048
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2049
                                        skip=0;
2050
                                }
2051
                        }
2052
                    }
2053
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2054
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2055
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2056
                            best_nb_frames= ist->st->codec_info_nb_frames;
2057
                            ost->source_index = j;
2058
                            found = 1;
2059
                        }
2060
                    }
2061
                }
2062

    
2063
                if (!found) {
2064
                    if(! opt_programid) {
2065
                        /* try again and reuse existing stream */
2066
                        for(j=0;j<nb_istreams;j++) {
2067
                            ist = ist_table[j];
2068
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2069
                                && ist->st->discard != AVDISCARD_ALL) {
2070
                                ost->source_index = j;
2071
                                found = 1;
2072
                            }
2073
                        }
2074
                    }
2075
                    if (!found) {
2076
                        int i= ost->file_index;
2077
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
2078
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2079
                                ost->file_index, ost->index);
2080
                        ffmpeg_exit(1);
2081
                    }
2082
                }
2083
            }
2084
            ist = ist_table[ost->source_index];
2085
            ist->discard = 0;
2086
            ost->sync_ist = (nb_stream_maps > 0) ?
2087
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2088
                         stream_maps[n].sync_stream_index] : ist;
2089
        }
2090
    }
2091

    
2092
    /* for each output stream, we compute the right encoding parameters */
2093
    for(i=0;i<nb_ostreams;i++) {
2094
        AVMetadataTag *t = NULL;
2095
        ost = ost_table[i];
2096
        os = output_files[ost->file_index];
2097
        ist = ist_table[ost->source_index];
2098

    
2099
        codec = ost->st->codec;
2100
        icodec = ist->st->codec;
2101

    
2102
        if (metadata_streams_autocopy)
2103
            while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2104
                av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2105
            }
2106

    
2107
        ost->st->disposition = ist->st->disposition;
2108
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2109
        codec->chroma_sample_location = icodec->chroma_sample_location;
2110

    
2111
        if (ost->st->stream_copy) {
2112
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2113

    
2114
            if (extra_size > INT_MAX)
2115
                goto fail;
2116

    
2117
            /* if stream_copy is selected, no need to decode or encode */
2118
            codec->codec_id = icodec->codec_id;
2119
            codec->codec_type = icodec->codec_type;
2120

    
2121
            if(!codec->codec_tag){
2122
                if(   !os->oformat->codec_tag
2123
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2124
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2125
                    codec->codec_tag = icodec->codec_tag;
2126
            }
2127

    
2128
            codec->bit_rate = icodec->bit_rate;
2129
            codec->rc_max_rate    = icodec->rc_max_rate;
2130
            codec->rc_buffer_size = icodec->rc_buffer_size;
2131
            codec->extradata= av_mallocz(extra_size);
2132
            if (!codec->extradata)
2133
                goto fail;
2134
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2135
            codec->extradata_size= icodec->extradata_size;
2136
            if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
2137
                codec->time_base = icodec->time_base;
2138
                codec->time_base.num *= icodec->ticks_per_frame;
2139
                av_reduce(&codec->time_base.num, &codec->time_base.den,
2140
                          codec->time_base.num, codec->time_base.den, INT_MAX);
2141
            }else
2142
                codec->time_base = ist->st->time_base;
2143
            switch(codec->codec_type) {
2144
            case AVMEDIA_TYPE_AUDIO:
2145
                if(audio_volume != 256) {
2146
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2147
                    ffmpeg_exit(1);
2148
                }
2149
                codec->channel_layout = icodec->channel_layout;
2150
                codec->sample_rate = icodec->sample_rate;
2151
                codec->channels = icodec->channels;
2152
                codec->frame_size = icodec->frame_size;
2153
                codec->block_align= icodec->block_align;
2154
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2155
                    codec->block_align= 0;
2156
                if(codec->codec_id == CODEC_ID_AC3)
2157
                    codec->block_align= 0;
2158
                break;
2159
            case AVMEDIA_TYPE_VIDEO:
2160
                codec->pix_fmt = icodec->pix_fmt;
2161
                codec->width = icodec->width;
2162
                codec->height = icodec->height;
2163
                codec->has_b_frames = icodec->has_b_frames;
2164
                break;
2165
            case AVMEDIA_TYPE_SUBTITLE:
2166
                codec->width = icodec->width;
2167
                codec->height = icodec->height;
2168
                break;
2169
            default:
2170
                abort();
2171
            }
2172
        } else {
2173
            switch(codec->codec_type) {
2174
            case AVMEDIA_TYPE_AUDIO:
2175
                ost->fifo= av_fifo_alloc(1024);
2176
                if(!ost->fifo)
2177
                    goto fail;
2178
                ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
2179
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2180
                icodec->request_channels = codec->channels;
2181
                ist->decoding_needed = 1;
2182
                ost->encoding_needed = 1;
2183
                break;
2184
            case AVMEDIA_TYPE_VIDEO:
2185
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2186
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2187
                    ffmpeg_exit(1);
2188
                }
2189
                ost->video_resample = (codec->width != icodec->width   ||
2190
                                       codec->height != icodec->height ||
2191
                        (codec->pix_fmt != icodec->pix_fmt));
2192
                if (ost->video_resample) {
2193
                    avcodec_get_frame_defaults(&ost->pict_tmp);
2194
                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2195
                                         codec->width, codec->height)) {
2196
                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2197
                        ffmpeg_exit(1);
2198
                    }
2199
                    sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2200
                    ost->img_resample_ctx = sws_getContext(
2201
                        icodec->width,
2202
                        icodec->height,
2203
                            icodec->pix_fmt,
2204
                            codec->width,
2205
                            codec->height,
2206
                            codec->pix_fmt,
2207
                            sws_flags, NULL, NULL, NULL);
2208
                    if (ost->img_resample_ctx == NULL) {
2209
                        fprintf(stderr, "Cannot get resampling context\n");
2210
                        ffmpeg_exit(1);
2211
                    }
2212

    
2213
#if !CONFIG_AVFILTER
2214
                    ost->original_height = icodec->height;
2215
                    ost->original_width  = icodec->width;
2216
#endif
2217
                    codec->bits_per_raw_sample= 0;
2218
                }
2219
                ost->resample_height = icodec->height;
2220
                ost->resample_width  = icodec->width;
2221
                ost->resample_pix_fmt= icodec->pix_fmt;
2222
                ost->encoding_needed = 1;
2223
                ist->decoding_needed = 1;
2224

    
2225
#if CONFIG_AVFILTER
2226
                if (configure_filters(ist, ost)) {
2227
                    fprintf(stderr, "Error opening filters!\n");
2228
                    exit(1);
2229
                }
2230
#endif
2231
                break;
2232
            case AVMEDIA_TYPE_SUBTITLE:
2233
                ost->encoding_needed = 1;
2234
                ist->decoding_needed = 1;
2235
                break;
2236
            default:
2237
                abort();
2238
                break;
2239
            }
2240
            /* two pass mode */
2241
            if (ost->encoding_needed &&
2242
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2243
                char logfilename[1024];
2244
                FILE *f;
2245

    
2246
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2247
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2248
                         i);
2249
                if (codec->flags & CODEC_FLAG_PASS1) {
2250
                    f = fopen(logfilename, "wb");
2251
                    if (!f) {
2252
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2253
                        ffmpeg_exit(1);
2254
                    }
2255
                    ost->logfile = f;
2256
                } else {
2257
                    char  *logbuffer;
2258
                    size_t logbuffer_size;
2259
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2260
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2261
                        ffmpeg_exit(1);
2262
                    }
2263
                    codec->stats_in = logbuffer;
2264
                }
2265
            }
2266
        }
2267
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2268
            int size= codec->width * codec->height;
2269
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2270
        }
2271
    }
2272

    
2273
    if (!bit_buffer)
2274
        bit_buffer = av_malloc(bit_buffer_size);
2275
    if (!bit_buffer) {
2276
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2277
                bit_buffer_size);
2278
        ret = AVERROR(ENOMEM);
2279
        goto fail;
2280
    }
2281

    
2282
    /* open each encoder */
2283
    for(i=0;i<nb_ostreams;i++) {
2284
        ost = ost_table[i];
2285
        if (ost->encoding_needed) {
2286
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2287
            if (!codec)
2288
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2289
            if (!codec) {
2290
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2291
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2292
                ret = AVERROR(EINVAL);
2293
                goto dump_format;
2294
            }
2295
            if (avcodec_open(ost->st->codec, codec) < 0) {
2296
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2297
                        ost->file_index, ost->index);
2298
                ret = AVERROR(EINVAL);
2299
                goto dump_format;
2300
            }
2301
            extra_size += ost->st->codec->extradata_size;
2302
        }
2303
    }
2304

    
2305
    /* open each decoder */
2306
    for(i=0;i<nb_istreams;i++) {
2307
        ist = ist_table[i];
2308
        if (ist->decoding_needed) {
2309
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2310
            if (!codec)
2311
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2312
            if (!codec) {
2313
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2314
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2315
                ret = AVERROR(EINVAL);
2316
                goto dump_format;
2317
            }
2318
            if (avcodec_open(ist->st->codec, codec) < 0) {
2319
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2320
                        ist->file_index, ist->index);
2321
                ret = AVERROR(EINVAL);
2322
                goto dump_format;
2323
            }
2324
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2325
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2326
        }
2327
    }
2328

    
2329
    /* init pts */
2330
    for(i=0;i<nb_istreams;i++) {
2331
        AVStream *st;
2332
        ist = ist_table[i];
2333
        st= ist->st;
2334
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2335
        ist->next_pts = AV_NOPTS_VALUE;
2336
        init_pts_correction(&ist->pts_ctx);
2337
        ist->is_start = 1;
2338
    }
2339

    
2340
    /* set meta data information from input file if required */
2341
    for (i=0;i<nb_meta_data_maps;i++) {
2342
        AVFormatContext *files[2];
2343
        AVMetadata      **meta[2];
2344
        AVMetadataTag *mtag;
2345
        int j;
2346

    
2347
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2348
        if ((index) < 0 || (index) >= (nb_elems)) {\
2349
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2350
                     (desc), (index));\
2351
            ret = AVERROR(EINVAL);\
2352
            goto dump_format;\
2353
        }
2354

    
2355
        int out_file_index = meta_data_maps[i][0].file;
2356
        int in_file_index = meta_data_maps[i][1].file;
2357
        if (in_file_index < 0 || out_file_index < 0)
2358
            continue;
2359
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2360
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2361

    
2362
        files[0] = output_files[out_file_index];
2363
        files[1] = input_files[in_file_index];
2364

    
2365
        for (j = 0; j < 2; j++) {
2366
            AVMetaDataMap *map = &meta_data_maps[i][j];
2367

    
2368
            switch (map->type) {
2369
            case 'g':
2370
                meta[j] = &files[j]->metadata;
2371
                break;
2372
            case 's':
2373
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2374
                meta[j] = &files[j]->streams[map->index]->metadata;
2375
                break;
2376
            case 'c':
2377
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2378
                meta[j] = &files[j]->chapters[map->index]->metadata;
2379
                break;
2380
            case 'p':
2381
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2382
                meta[j] = &files[j]->programs[map->index]->metadata;
2383
                break;
2384
            }
2385
        }
2386

    
2387
        mtag=NULL;
2388
        while((mtag=av_metadata_get(*meta[1], "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2389
            av_metadata_set2(meta[0], mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2390
    }
2391

    
2392
    /* copy chapters according to chapter maps */
2393
    for (i = 0; i < nb_chapter_maps; i++) {
2394
        int infile  = chapter_maps[i].in_file;
2395
        int outfile = chapter_maps[i].out_file;
2396

    
2397
        if (infile < 0 || outfile < 0)
2398
            continue;
2399
        if (infile >= nb_input_files) {
2400
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2401
            ret = AVERROR(EINVAL);
2402
            goto dump_format;
2403
        }
2404
        if (outfile >= nb_output_files) {
2405
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2406
            ret = AVERROR(EINVAL);
2407
            goto dump_format;
2408
        }
2409
        copy_chapters(infile, outfile);
2410
    }
2411

    
2412
    /* copy chapters from the first input file that has them*/
2413
    if (!nb_chapter_maps)
2414
    for (i = 0; i < nb_input_files; i++) {
2415
        if (!input_files[i]->nb_chapters)
2416
            continue;
2417

    
2418
        for (j = 0; j < nb_output_files; j++)
2419
            if ((ret = copy_chapters(i, j)) < 0)
2420
                goto dump_format;
2421
    }
2422

    
2423
    /* open files and write file headers */
2424
    for(i=0;i<nb_output_files;i++) {
2425
        os = output_files[i];
2426
        if (av_write_header(os) < 0) {
2427
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2428
            ret = AVERROR(EINVAL);
2429
            goto dump_format;
2430
        }
2431
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2432
            want_sdp = 0;
2433
        }
2434
    }
2435

    
2436
 dump_format:
2437
    /* dump the file output parameters - cannot be done before in case
2438
       of stream copy */
2439
    for(i=0;i<nb_output_files;i++) {
2440
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2441
    }
2442

    
2443
    /* dump the stream mapping */
2444
    if (verbose >= 0) {
2445
        fprintf(stderr, "Stream mapping:\n");
2446
        for(i=0;i<nb_ostreams;i++) {
2447
            ost = ost_table[i];
2448
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2449
                    ist_table[ost->source_index]->file_index,
2450
                    ist_table[ost->source_index]->index,
2451
                    ost->file_index,
2452
                    ost->index);
2453
            if (ost->sync_ist != ist_table[ost->source_index])
2454
                fprintf(stderr, " [sync #%d.%d]",
2455
                        ost->sync_ist->file_index,
2456
                        ost->sync_ist->index);
2457
            fprintf(stderr, "\n");
2458
        }
2459
    }
2460

    
2461
    if (ret) {
2462
        fprintf(stderr, "%s\n", error);
2463
        goto fail;
2464
    }
2465

    
2466
    if (want_sdp) {
2467
        print_sdp(output_files, nb_output_files);
2468
    }
2469

    
2470
    if (!using_stdin && verbose >= 0) {
2471
        fprintf(stderr, "Press [q] to stop encoding\n");
2472
        url_set_interrupt_cb(decode_interrupt_cb);
2473
    }
2474
    term_init();
2475

    
2476
    timer_start = av_gettime();
2477

    
2478
    for(; received_sigterm == 0;) {
2479
        int file_index, ist_index;
2480
        AVPacket pkt;
2481
        double ipts_min;
2482
        double opts_min;
2483

    
2484
    redo:
2485
        ipts_min= 1e100;
2486
        opts_min= 1e100;
2487
        /* if 'q' pressed, exits */
2488
        if (!using_stdin) {
2489
            if (q_pressed)
2490
                break;
2491
            /* read_key() returns 0 on EOF */
2492
            key = read_key();
2493
            if (key == 'q')
2494
                break;
2495
        }
2496

    
2497
        /* select the stream that we must read now by looking at the
2498
           smallest output pts */
2499
        file_index = -1;
2500
        for(i=0;i<nb_ostreams;i++) {
2501
            double ipts, opts;
2502
            ost = ost_table[i];
2503
            os = output_files[ost->file_index];
2504
            ist = ist_table[ost->source_index];
2505
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2506
                continue;
2507
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2508
            ipts = (double)ist->pts;
2509
            if (!file_table[ist->file_index].eof_reached){
2510
                if(ipts < ipts_min) {
2511
                    ipts_min = ipts;
2512
                    if(input_sync ) file_index = ist->file_index;
2513
                }
2514
                if(opts < opts_min) {
2515
                    opts_min = opts;
2516
                    if(!input_sync) file_index = ist->file_index;
2517
                }
2518
            }
2519
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2520
                file_index= -1;
2521
                break;
2522
            }
2523
        }
2524
        /* if none, if is finished */
2525
        if (file_index < 0) {
2526
            if(no_packet_count){
2527
                no_packet_count=0;
2528
                memset(no_packet, 0, sizeof(no_packet));
2529
                usleep(10000);
2530
                continue;
2531
            }
2532
            break;
2533
        }
2534

    
2535
        /* finish if limit size exhausted */
2536
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2537
            break;
2538

    
2539
        /* read a frame from it and output it in the fifo */
2540
        is = input_files[file_index];
2541
        ret= av_read_frame(is, &pkt);
2542
        if(ret == AVERROR(EAGAIN)){
2543
            no_packet[file_index]=1;
2544
            no_packet_count++;
2545
            continue;
2546
        }
2547
        if (ret < 0) {
2548
            file_table[file_index].eof_reached = 1;
2549
            if (opt_shortest)
2550
                break;
2551
            else
2552
                continue;
2553
        }
2554

    
2555
        no_packet_count=0;
2556
        memset(no_packet, 0, sizeof(no_packet));
2557

    
2558
        if (do_pkt_dump) {
2559
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2560
        }
2561
        /* the following test is needed in case new streams appear
2562
           dynamically in stream : we ignore them */
2563
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2564
            goto discard_packet;
2565
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2566
        ist = ist_table[ist_index];
2567
        if (ist->discard)
2568
            goto discard_packet;
2569

    
2570
        if (pkt.dts != AV_NOPTS_VALUE)
2571
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2572
        if (pkt.pts != AV_NOPTS_VALUE)
2573
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2574

    
2575
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2576
            && input_files_ts_scale[file_index][pkt.stream_index]){
2577
            if(pkt.pts != AV_NOPTS_VALUE)
2578
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2579
            if(pkt.dts != AV_NOPTS_VALUE)
2580
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2581
        }
2582

    
2583
//        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);
2584
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2585
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2586
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2587
            int64_t delta= pkt_dts - ist->next_pts;
2588
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2589
                input_files_ts_offset[ist->file_index]-= delta;
2590
                if (verbose > 2)
2591
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2592
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2593
                if(pkt.pts != AV_NOPTS_VALUE)
2594
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2595
            }
2596
        }
2597

    
2598
        /* finish if recording time exhausted */
2599
        if (recording_time != INT64_MAX &&
2600
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2601
            ist->is_past_recording_time = 1;
2602
            goto discard_packet;
2603
        }
2604

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

    
2608
            if (verbose >= 0)
2609
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2610
                        ist->file_index, ist->index);
2611
            if (exit_on_error)
2612
                ffmpeg_exit(1);
2613
            av_free_packet(&pkt);
2614
            goto redo;
2615
        }
2616

    
2617
    discard_packet:
2618
        av_free_packet(&pkt);
2619

    
2620
        /* dump report by using the output first video and audio streams */
2621
        print_report(output_files, ost_table, nb_ostreams, 0);
2622
    }
2623

    
2624
    /* at the end of stream, we must flush the decoder buffers */
2625
    for(i=0;i<nb_istreams;i++) {
2626
        ist = ist_table[i];
2627
        if (ist->decoding_needed) {
2628
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2629
        }
2630
    }
2631

    
2632
    term_exit();
2633

    
2634
    /* write the trailer if needed and close file */
2635
    for(i=0;i<nb_output_files;i++) {
2636
        os = output_files[i];
2637
        av_write_trailer(os);
2638
    }
2639

    
2640
    /* dump report by using the first video and audio streams */
2641
    print_report(output_files, ost_table, nb_ostreams, 1);
2642

    
2643
    /* close each encoder */
2644
    for(i=0;i<nb_ostreams;i++) {
2645
        ost = ost_table[i];
2646
        if (ost->encoding_needed) {
2647
            av_freep(&ost->st->codec->stats_in);
2648
            avcodec_close(ost->st->codec);
2649
        }
2650
    }
2651

    
2652
    /* close each decoder */
2653
    for(i=0;i<nb_istreams;i++) {
2654
        ist = ist_table[i];
2655
        if (ist->decoding_needed) {
2656
            avcodec_close(ist->st->codec);
2657
        }
2658
    }
2659
#if CONFIG_AVFILTER
2660
    if (graph) {
2661
        avfilter_graph_free(graph);
2662
        av_freep(&graph);
2663
    }
2664
#endif
2665

    
2666
    /* finished ! */
2667
    ret = 0;
2668

    
2669
 fail:
2670
    av_freep(&bit_buffer);
2671
    av_free(file_table);
2672

    
2673
    if (ist_table) {
2674
        for(i=0;i<nb_istreams;i++) {
2675
            ist = ist_table[i];
2676
            av_free(ist);
2677
        }
2678
        av_free(ist_table);
2679
    }
2680
    if (ost_table) {
2681
        for(i=0;i<nb_ostreams;i++) {
2682
            ost = ost_table[i];
2683
            if (ost) {
2684
                if (ost->st->stream_copy)
2685
                    av_freep(&ost->st->codec->extradata);
2686
                if (ost->logfile) {
2687
                    fclose(ost->logfile);
2688
                    ost->logfile = NULL;
2689
                }
2690
                av_fifo_free(ost->fifo); /* works even if fifo is not
2691
                                             initialized but set to zero */
2692
                av_free(ost->pict_tmp.data[0]);
2693
                av_free(ost->forced_kf_pts);
2694
                if (ost->video_resample)
2695
                    sws_freeContext(ost->img_resample_ctx);
2696
                if (ost->resample)
2697
                    audio_resample_close(ost->resample);
2698
                if (ost->reformat_ctx)
2699
                    av_audio_convert_free(ost->reformat_ctx);
2700
                av_free(ost);
2701
            }
2702
        }
2703
        av_free(ost_table);
2704
    }
2705
    return ret;
2706
}
2707

    
2708
static void opt_format(const char *arg)
2709
{
2710
    last_asked_format = arg;
2711
}
2712

    
2713
static void opt_video_rc_override_string(const char *arg)
2714
{
2715
    video_rc_override_string = arg;
2716
}
2717

    
2718
static int opt_me_threshold(const char *opt, const char *arg)
2719
{
2720
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2721
    return 0;
2722
}
2723

    
2724
static int opt_verbose(const char *opt, const char *arg)
2725
{
2726
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2727
    return 0;
2728
}
2729

    
2730
static int opt_frame_rate(const char *opt, const char *arg)
2731
{
2732
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2733
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2734
        ffmpeg_exit(1);
2735
    }
2736
    return 0;
2737
}
2738

    
2739
static int opt_bitrate(const char *opt, const char *arg)
2740
{
2741
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2742

    
2743
    opt_default(opt, arg);
2744

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

    
2748
    return 0;
2749
}
2750

    
2751
static int opt_frame_crop(const char *opt, const char *arg)
2752
{
2753
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2754
    return AVERROR(EINVAL);
2755
}
2756

    
2757
static void opt_frame_size(const char *arg)
2758
{
2759
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2760
        fprintf(stderr, "Incorrect frame size\n");
2761
        ffmpeg_exit(1);
2762
    }
2763
}
2764

    
2765
static int opt_pad(const char *opt, const char *arg) {
2766
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2767
    return -1;
2768
}
2769

    
2770
static void opt_frame_pix_fmt(const char *arg)
2771
{
2772
    if (strcmp(arg, "list")) {
2773
        frame_pix_fmt = av_get_pix_fmt(arg);
2774
        if (frame_pix_fmt == PIX_FMT_NONE) {
2775
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2776
            ffmpeg_exit(1);
2777
        }
2778
    } else {
2779
        show_pix_fmts();
2780
        ffmpeg_exit(0);
2781
    }
2782
}
2783

    
2784
static void opt_frame_aspect_ratio(const char *arg)
2785
{
2786
    int x = 0, y = 0;
2787
    double ar = 0;
2788
    const char *p;
2789
    char *end;
2790

    
2791
    p = strchr(arg, ':');
2792
    if (p) {
2793
        x = strtol(arg, &end, 10);
2794
        if (end == p)
2795
            y = strtol(end+1, &end, 10);
2796
        if (x > 0 && y > 0)
2797
            ar = (double)x / (double)y;
2798
    } else
2799
        ar = strtod(arg, NULL);
2800

    
2801
    if (!ar) {
2802
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2803
        ffmpeg_exit(1);
2804
    }
2805
    frame_aspect_ratio = ar;
2806
}
2807

    
2808
static int opt_metadata(const char *opt, const char *arg)
2809
{
2810
    char *mid= strchr(arg, '=');
2811

    
2812
    if(!mid){
2813
        fprintf(stderr, "Missing =\n");
2814
        ffmpeg_exit(1);
2815
    }
2816
    *mid++= 0;
2817

    
2818
    av_metadata_set2(&metadata, arg, mid, 0);
2819

    
2820
    return 0;
2821
}
2822

    
2823
static void opt_qscale(const char *arg)
2824
{
2825
    video_qscale = atof(arg);
2826
    if (video_qscale <= 0 ||
2827
        video_qscale > 255) {
2828
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2829
        ffmpeg_exit(1);
2830
    }
2831
}
2832

    
2833
static void opt_top_field_first(const char *arg)
2834
{
2835
    top_field_first= atoi(arg);
2836
}
2837

    
2838
static int opt_thread_count(const char *opt, const char *arg)
2839
{
2840
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2841
#if !HAVE_THREADS
2842
    if (verbose >= 0)
2843
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2844
#endif
2845
    return 0;
2846
}
2847

    
2848
static void opt_audio_sample_fmt(const char *arg)
2849
{
2850
    if (strcmp(arg, "list"))
2851
        audio_sample_fmt = av_get_sample_fmt(arg);
2852
    else {
2853
        list_fmts(av_get_sample_fmt_string, SAMPLE_FMT_NB);
2854
        ffmpeg_exit(0);
2855
    }
2856
}
2857

    
2858
static int opt_audio_rate(const char *opt, const char *arg)
2859
{
2860
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2861
    return 0;
2862
}
2863

    
2864
static int opt_audio_channels(const char *opt, const char *arg)
2865
{
2866
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2867
    return 0;
2868
}
2869

    
2870
static void opt_video_channel(const char *arg)
2871
{
2872
    video_channel = strtol(arg, NULL, 0);
2873
}
2874

    
2875
static void opt_video_standard(const char *arg)
2876
{
2877
    video_standard = av_strdup(arg);
2878
}
2879

    
2880
static void opt_codec(int *pstream_copy, char **pcodec_name,
2881
                      int codec_type, const char *arg)
2882
{
2883
    av_freep(pcodec_name);
2884
    if (!strcmp(arg, "copy")) {
2885
        *pstream_copy = 1;
2886
    } else {
2887
        *pcodec_name = av_strdup(arg);
2888
    }
2889
}
2890

    
2891
static void opt_audio_codec(const char *arg)
2892
{
2893
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2894
}
2895

    
2896
static void opt_video_codec(const char *arg)
2897
{
2898
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2899
}
2900

    
2901
static void opt_subtitle_codec(const char *arg)
2902
{
2903
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2904
}
2905

    
2906
static int opt_codec_tag(const char *opt, const char *arg)
2907
{
2908
    char *tail;
2909
    uint32_t *codec_tag;
2910

    
2911
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2912
                !strcmp(opt, "vtag") ? &video_codec_tag :
2913
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2914
    if (!codec_tag)
2915
        return -1;
2916

    
2917
    *codec_tag = strtol(arg, &tail, 0);
2918
    if (!tail || *tail)
2919
        *codec_tag = AV_RL32(arg);
2920

    
2921
    return 0;
2922
}
2923

    
2924
static void opt_map(const char *arg)
2925
{
2926
    AVStreamMap *m;
2927
    char *p;
2928

    
2929
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2930
    m = &stream_maps[nb_stream_maps-1];
2931

    
2932
    m->file_index = strtol(arg, &p, 0);
2933
    if (*p)
2934
        p++;
2935

    
2936
    m->stream_index = strtol(p, &p, 0);
2937
    if (*p) {
2938
        p++;
2939
        m->sync_file_index = strtol(p, &p, 0);
2940
        if (*p)
2941
            p++;
2942
        m->sync_stream_index = strtol(p, &p, 0);
2943
    } else {
2944
        m->sync_file_index = m->file_index;
2945
        m->sync_stream_index = m->stream_index;
2946
    }
2947
}
2948

    
2949
static void parse_meta_type(const char *arg, char *type, int *index, char **endptr)
2950
{
2951
    *endptr = arg;
2952
    if (*arg == ',') {
2953
        *type = *(++arg);
2954
        switch (*arg) {
2955
        case 'g':
2956
            break;
2957
        case 's':
2958
        case 'c':
2959
        case 'p':
2960
            *index = strtol(++arg, endptr, 0);
2961
            break;
2962
        default:
2963
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2964
            ffmpeg_exit(1);
2965
        }
2966
    } else
2967
        *type = 'g';
2968
}
2969

    
2970
static void opt_map_meta_data(const char *arg)
2971
{
2972
    AVMetaDataMap *m, *m1;
2973
    char *p;
2974

    
2975
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2976
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2977

    
2978
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
2979
    m->file = strtol(arg, &p, 0);
2980
    parse_meta_type(p, &m->type, &m->index, &p);
2981
    if (*p)
2982
        p++;
2983

    
2984
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2985
    m1->file = strtol(p, &p, 0);
2986
    parse_meta_type(p, &m1->type, &m1->index, &p);
2987

    
2988
    if (m->type == 's' || m1->type == 's')
2989
        metadata_streams_autocopy = 0;
2990
    if (m->type == 'c' || m1->type == 'c')
2991
        metadata_chapters_autocopy = 0;
2992
}
2993

    
2994
static void opt_map_chapters(const char *arg)
2995
{
2996
    AVChapterMap *c;
2997
    char *p;
2998

    
2999
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3000
                              nb_chapter_maps + 1);
3001
    c = &chapter_maps[nb_chapter_maps - 1];
3002
    c->out_file = strtol(arg, &p, 0);
3003
    if (*p)
3004
        p++;
3005

    
3006
    c->in_file = strtol(p, &p, 0);
3007
}
3008

    
3009
static void opt_input_ts_scale(const char *arg)
3010
{
3011
    unsigned int stream;
3012
    double scale;
3013
    char *p;
3014

    
3015
    stream = strtol(arg, &p, 0);
3016
    if (*p)
3017
        p++;
3018
    scale= strtod(p, &p);
3019

    
3020
    if(stream >= MAX_STREAMS)
3021
        ffmpeg_exit(1);
3022

    
3023
    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);
3024
    input_files_ts_scale[nb_input_files][stream]= scale;
3025
}
3026

    
3027
static int opt_recording_time(const char *opt, const char *arg)
3028
{
3029
    recording_time = parse_time_or_die(opt, arg, 1);
3030
    return 0;
3031
}
3032

    
3033
static int opt_start_time(const char *opt, const char *arg)
3034
{
3035
    start_time = parse_time_or_die(opt, arg, 1);
3036
    return 0;
3037
}
3038

    
3039
static int opt_recording_timestamp(const char *opt, const char *arg)
3040
{
3041
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3042
    return 0;
3043
}
3044

    
3045
static int opt_input_ts_offset(const char *opt, const char *arg)
3046
{
3047
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3048
    return 0;
3049
}
3050

    
3051
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3052
{
3053
    const char *codec_string = encoder ? "encoder" : "decoder";
3054
    AVCodec *codec;
3055

    
3056
    if(!name)
3057
        return CODEC_ID_NONE;
3058
    codec = encoder ?
3059
        avcodec_find_encoder_by_name(name) :
3060
        avcodec_find_decoder_by_name(name);
3061
    if(!codec) {
3062
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3063
        ffmpeg_exit(1);
3064
    }
3065
    if(codec->type != type) {
3066
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3067
        ffmpeg_exit(1);
3068
    }
3069
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3070
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3071
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3072
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3073
                codec_string, codec->name);
3074
        codec = encoder ?
3075
            avcodec_find_encoder(codec->id) :
3076
            avcodec_find_decoder(codec->id);
3077
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3078
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3079
                    codec_string, codec->name);
3080
        ffmpeg_exit(1);
3081
    }
3082
    return codec->id;
3083
}
3084

    
3085
static void opt_input_file(const char *filename)
3086
{
3087
    AVFormatContext *ic;
3088
    AVFormatParameters params, *ap = &params;
3089
    AVInputFormat *file_iformat = NULL;
3090
    int err, i, ret, rfps, rfps_base;
3091
    int64_t timestamp;
3092

    
3093
    if (last_asked_format) {
3094
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3095
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3096
            ffmpeg_exit(1);
3097
        }
3098
        last_asked_format = NULL;
3099
    }
3100

    
3101
    if (!strcmp(filename, "-"))
3102
        filename = "pipe:";
3103

    
3104
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3105
                    !strcmp(filename, "/dev/stdin");
3106

    
3107
    /* get default parameters from command line */
3108
    ic = avformat_alloc_context();
3109
    if (!ic) {
3110
        print_error(filename, AVERROR(ENOMEM));
3111
        ffmpeg_exit(1);
3112
    }
3113

    
3114
    memset(ap, 0, sizeof(*ap));
3115
    ap->prealloced_context = 1;
3116
    ap->sample_rate = audio_sample_rate;
3117
    ap->channels = audio_channels;
3118
    ap->time_base.den = frame_rate.num;
3119
    ap->time_base.num = frame_rate.den;
3120
    ap->width = frame_width;
3121
    ap->height = frame_height;
3122
    ap->pix_fmt = frame_pix_fmt;
3123
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3124
    ap->channel = video_channel;
3125
    ap->standard = video_standard;
3126

    
3127
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3128

    
3129
    ic->video_codec_id   =
3130
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3131
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3132
    ic->audio_codec_id   =
3133
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3134
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3135
    ic->subtitle_codec_id=
3136
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3137
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3138
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3139

    
3140
    /* open the input file with generic libav function */
3141
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3142
    if (err < 0) {
3143
        print_error(filename, err);
3144
        ffmpeg_exit(1);
3145
    }
3146
    if(opt_programid) {
3147
        int i, j;
3148
        int found=0;
3149
        for(i=0; i<ic->nb_streams; i++){
3150
            ic->streams[i]->discard= AVDISCARD_ALL;
3151
        }
3152
        for(i=0; i<ic->nb_programs; i++){
3153
            AVProgram *p= ic->programs[i];
3154
            if(p->id != opt_programid){
3155
                p->discard = AVDISCARD_ALL;
3156
            }else{
3157
                found=1;
3158
                for(j=0; j<p->nb_stream_indexes; j++){
3159
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3160
                }
3161
            }
3162
        }
3163
        if(!found){
3164
            fprintf(stderr, "Specified program id not found\n");
3165
            ffmpeg_exit(1);
3166
        }
3167
        opt_programid=0;
3168
    }
3169

    
3170
    ic->loop_input = loop_input;
3171

    
3172
    /* If not enough info to get the stream parameters, we decode the
3173
       first frames to get it. (used in mpeg case for example) */
3174
    ret = av_find_stream_info(ic);
3175
    if (ret < 0 && verbose >= 0) {
3176
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3177
        av_close_input_file(ic);
3178
        ffmpeg_exit(1);
3179
    }
3180

    
3181
    timestamp = start_time;
3182
    /* add the stream start time */
3183
    if (ic->start_time != AV_NOPTS_VALUE)
3184
        timestamp += ic->start_time;
3185

    
3186
    /* if seeking requested, we execute it */
3187
    if (start_time != 0) {
3188
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3189
        if (ret < 0) {
3190
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3191
                    filename, (double)timestamp / AV_TIME_BASE);
3192
        }
3193
        /* reset seek info */
3194
        start_time = 0;
3195
    }
3196

    
3197
    /* update the current parameters so that they match the one of the input stream */
3198
    for(i=0;i<ic->nb_streams;i++) {
3199
        AVStream *st = ic->streams[i];
3200
        AVCodecContext *dec = st->codec;
3201
        avcodec_thread_init(dec, thread_count);
3202
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3203
        switch (dec->codec_type) {
3204
        case AVMEDIA_TYPE_AUDIO:
3205
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3206
            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]);
3207
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3208
            channel_layout    = dec->channel_layout;
3209
            audio_channels    = dec->channels;
3210
            audio_sample_rate = dec->sample_rate;
3211
            audio_sample_fmt  = dec->sample_fmt;
3212
            if(audio_disable)
3213
                st->discard= AVDISCARD_ALL;
3214
            /* Note that av_find_stream_info can add more streams, and we
3215
             * currently have no chance of setting up lowres decoding
3216
             * early enough for them. */
3217
            if (dec->lowres)
3218
                audio_sample_rate >>= dec->lowres;
3219
            break;
3220
        case AVMEDIA_TYPE_VIDEO:
3221
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3222
            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]);
3223
            frame_height = dec->height;
3224
            frame_width  = dec->width;
3225
            if(ic->streams[i]->sample_aspect_ratio.num)
3226
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3227
            else
3228
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3229
            frame_aspect_ratio *= (float) dec->width / dec->height;
3230
            frame_pix_fmt = dec->pix_fmt;
3231
            rfps      = ic->streams[i]->r_frame_rate.num;
3232
            rfps_base = ic->streams[i]->r_frame_rate.den;
3233
            if (dec->lowres) {
3234
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3235
                frame_height >>= dec->lowres;
3236
                frame_width  >>= dec->lowres;
3237
            }
3238
            if(me_threshold)
3239
                dec->debug |= FF_DEBUG_MV;
3240

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

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

    
3247
                    (float)rfps / rfps_base, rfps, rfps_base);
3248
            }
3249
            /* update the current frame rate to match the stream frame rate */
3250
            frame_rate.num = rfps;
3251
            frame_rate.den = rfps_base;
3252

    
3253
            if(video_disable)
3254
                st->discard= AVDISCARD_ALL;
3255
            else if(video_discard)
3256
                st->discard= video_discard;
3257
            break;
3258
        case AVMEDIA_TYPE_DATA:
3259
            break;
3260
        case AVMEDIA_TYPE_SUBTITLE:
3261
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3262
            if(subtitle_disable)
3263
                st->discard = AVDISCARD_ALL;
3264
            break;
3265
        case AVMEDIA_TYPE_ATTACHMENT:
3266
        case AVMEDIA_TYPE_UNKNOWN:
3267
            break;
3268
        default:
3269
            abort();
3270
        }
3271
    }
3272

    
3273
    input_files[nb_input_files] = ic;
3274
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3275
    /* dump the file content */
3276
    if (verbose >= 0)
3277
        dump_format(ic, nb_input_files, filename, 0);
3278

    
3279
    nb_input_files++;
3280

    
3281
    video_channel = 0;
3282

    
3283
    av_freep(&video_codec_name);
3284
    av_freep(&audio_codec_name);
3285
    av_freep(&subtitle_codec_name);
3286
}
3287

    
3288
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3289
                                         int *has_subtitle_ptr)
3290
{
3291
    int has_video, has_audio, has_subtitle, i, j;
3292
    AVFormatContext *ic;
3293

    
3294
    has_video = 0;
3295
    has_audio = 0;
3296
    has_subtitle = 0;
3297
    for(j=0;j<nb_input_files;j++) {
3298
        ic = input_files[j];
3299
        for(i=0;i<ic->nb_streams;i++) {
3300
            AVCodecContext *enc = ic->streams[i]->codec;
3301
            switch(enc->codec_type) {
3302
            case AVMEDIA_TYPE_AUDIO:
3303
                has_audio = 1;
3304
                break;
3305
            case AVMEDIA_TYPE_VIDEO:
3306
                has_video = 1;
3307
                break;
3308
            case AVMEDIA_TYPE_SUBTITLE:
3309
                has_subtitle = 1;
3310
                break;
3311
            case AVMEDIA_TYPE_DATA:
3312
            case AVMEDIA_TYPE_ATTACHMENT:
3313
            case AVMEDIA_TYPE_UNKNOWN:
3314
                break;
3315
            default:
3316
                abort();
3317
            }
3318
        }
3319
    }
3320
    *has_video_ptr = has_video;
3321
    *has_audio_ptr = has_audio;
3322
    *has_subtitle_ptr = has_subtitle;
3323
}
3324

    
3325
static void new_video_stream(AVFormatContext *oc, int file_idx)
3326
{
3327
    AVStream *st;
3328
    AVOutputStream *ost;
3329
    AVCodecContext *video_enc;
3330
    enum CodecID codec_id;
3331
    AVCodec *codec= NULL;
3332

    
3333
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3334
    if (!st) {
3335
        fprintf(stderr, "Could not alloc stream\n");
3336
        ffmpeg_exit(1);
3337
    }
3338
    ost = new_output_stream(oc, file_idx);
3339

    
3340
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3341
    if(!video_stream_copy){
3342
        if (video_codec_name) {
3343
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3344
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3345
            codec = avcodec_find_encoder_by_name(video_codec_name);
3346
            output_codecs[nb_output_codecs-1] = codec;
3347
        } else {
3348
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3349
            codec = avcodec_find_encoder(codec_id);
3350
        }
3351
    }
3352

    
3353
    avcodec_get_context_defaults3(st->codec, codec);
3354
    ost->bitstream_filters = video_bitstream_filters;
3355
    video_bitstream_filters= NULL;
3356

    
3357
    avcodec_thread_init(st->codec, thread_count);
3358

    
3359
    video_enc = st->codec;
3360

    
3361
    if(video_codec_tag)
3362
        video_enc->codec_tag= video_codec_tag;
3363

    
3364
    if(   (video_global_header&1)
3365
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3366
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3367
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3368
    }
3369
    if(video_global_header&2){
3370
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3371
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3372
    }
3373

    
3374
    if (video_stream_copy) {
3375
        st->stream_copy = 1;
3376
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3377
        video_enc->sample_aspect_ratio =
3378
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3379
    } else {
3380
        const char *p;
3381
        int i;
3382
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3383

    
3384
        video_enc->codec_id = codec_id;
3385
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3386

    
3387
        if (codec && codec->supported_framerates && !force_fps)
3388
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3389
        video_enc->time_base.den = fps.num;
3390
        video_enc->time_base.num = fps.den;
3391

    
3392
        video_enc->width = frame_width;
3393
        video_enc->height = frame_height;
3394
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3395
        video_enc->pix_fmt = frame_pix_fmt;
3396
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3397

    
3398
        choose_pixel_fmt(st, codec);
3399

    
3400
        if (intra_only)
3401
            video_enc->gop_size = 0;
3402
        if (video_qscale || same_quality) {
3403
            video_enc->flags |= CODEC_FLAG_QSCALE;
3404
            video_enc->global_quality=
3405
                st->quality = FF_QP2LAMBDA * video_qscale;
3406
        }
3407

    
3408
        if(intra_matrix)
3409
            video_enc->intra_matrix = intra_matrix;
3410
        if(inter_matrix)
3411
            video_enc->inter_matrix = inter_matrix;
3412

    
3413
        p= video_rc_override_string;
3414
        for(i=0; p; i++){
3415
            int start, end, q;
3416
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3417
            if(e!=3){
3418
                fprintf(stderr, "error parsing rc_override\n");
3419
                ffmpeg_exit(1);
3420
            }
3421
            video_enc->rc_override=
3422
                av_realloc(video_enc->rc_override,
3423
                           sizeof(RcOverride)*(i+1));
3424
            video_enc->rc_override[i].start_frame= start;
3425
            video_enc->rc_override[i].end_frame  = end;
3426
            if(q>0){
3427
                video_enc->rc_override[i].qscale= q;
3428
                video_enc->rc_override[i].quality_factor= 1.0;
3429
            }
3430
            else{
3431
                video_enc->rc_override[i].qscale= 0;
3432
                video_enc->rc_override[i].quality_factor= -q/100.0;
3433
            }
3434
            p= strchr(p, '/');
3435
            if(p) p++;
3436
        }
3437
        video_enc->rc_override_count=i;
3438
        if (!video_enc->rc_initial_buffer_occupancy)
3439
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3440
        video_enc->me_threshold= me_threshold;
3441
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3442

    
3443
        if (do_psnr)
3444
            video_enc->flags|= CODEC_FLAG_PSNR;
3445

    
3446
        /* two pass mode */
3447
        if (do_pass) {
3448
            if (do_pass == 1) {
3449
                video_enc->flags |= CODEC_FLAG_PASS1;
3450
            } else {
3451
                video_enc->flags |= CODEC_FLAG_PASS2;
3452
            }
3453
        }
3454

    
3455
        if (forced_key_frames)
3456
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3457
    }
3458
    if (video_language) {
3459
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3460
        av_freep(&video_language);
3461
    }
3462

    
3463
    /* reset some key parameters */
3464
    video_disable = 0;
3465
    av_freep(&video_codec_name);
3466
    av_freep(&forced_key_frames);
3467
    video_stream_copy = 0;
3468
    frame_pix_fmt = PIX_FMT_NONE;
3469
}
3470

    
3471
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3472
{
3473
    AVStream *st;
3474
    AVOutputStream *ost;
3475
    AVCodec *codec= NULL;
3476
    AVCodecContext *audio_enc;
3477
    enum CodecID codec_id;
3478

    
3479
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3480
    if (!st) {
3481
        fprintf(stderr, "Could not alloc stream\n");
3482
        ffmpeg_exit(1);
3483
    }
3484
    ost = new_output_stream(oc, file_idx);
3485

    
3486
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3487
    if(!audio_stream_copy){
3488
        if (audio_codec_name) {
3489
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3490
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3491
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3492
            output_codecs[nb_output_codecs-1] = codec;
3493
        } else {
3494
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3495
            codec = avcodec_find_encoder(codec_id);
3496
        }
3497
    }
3498

    
3499
    avcodec_get_context_defaults3(st->codec, codec);
3500

    
3501
    ost->bitstream_filters = audio_bitstream_filters;
3502
    audio_bitstream_filters= NULL;
3503

    
3504
    avcodec_thread_init(st->codec, thread_count);
3505

    
3506
    audio_enc = st->codec;
3507
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3508

    
3509
    if(audio_codec_tag)
3510
        audio_enc->codec_tag= audio_codec_tag;
3511

    
3512
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3513
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3514
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3515
    }
3516
    if (audio_stream_copy) {
3517
        st->stream_copy = 1;
3518
        audio_enc->channels = audio_channels;
3519
        audio_enc->sample_rate = audio_sample_rate;
3520
    } else {
3521
        audio_enc->codec_id = codec_id;
3522
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3523

    
3524
        if (audio_qscale > QSCALE_NONE) {
3525
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3526
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3527
        }
3528
        audio_enc->channels = audio_channels;
3529
        audio_enc->sample_fmt = audio_sample_fmt;
3530
        audio_enc->sample_rate = audio_sample_rate;
3531
        audio_enc->channel_layout = channel_layout;
3532
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3533
            audio_enc->channel_layout = 0;
3534
        choose_sample_fmt(st, codec);
3535
        choose_sample_rate(st, codec);
3536
    }
3537
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3538
    if (audio_language) {
3539
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3540
        av_freep(&audio_language);
3541
    }
3542

    
3543
    /* reset some key parameters */
3544
    audio_disable = 0;
3545
    av_freep(&audio_codec_name);
3546
    audio_stream_copy = 0;
3547
}
3548

    
3549
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3550
{
3551
    AVStream *st;
3552
    AVOutputStream *ost;
3553
    AVCodec *codec=NULL;
3554
    AVCodecContext *subtitle_enc;
3555

    
3556
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3557
    if (!st) {
3558
        fprintf(stderr, "Could not alloc stream\n");
3559
        ffmpeg_exit(1);
3560
    }
3561
    ost = new_output_stream(oc, file_idx);
3562
    subtitle_enc = st->codec;
3563
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3564
    if(!subtitle_stream_copy){
3565
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3566
                                                   avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3567
        codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3568
    }
3569
    avcodec_get_context_defaults3(st->codec, codec);
3570

    
3571
    ost->bitstream_filters = subtitle_bitstream_filters;
3572
    subtitle_bitstream_filters= NULL;
3573

    
3574
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3575

    
3576
    if(subtitle_codec_tag)
3577
        subtitle_enc->codec_tag= subtitle_codec_tag;
3578

    
3579
    if (subtitle_stream_copy) {
3580
        st->stream_copy = 1;
3581
    } else {
3582
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3583
    }
3584

    
3585
    if (subtitle_language) {
3586
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3587
        av_freep(&subtitle_language);
3588
    }
3589

    
3590
    subtitle_disable = 0;
3591
    av_freep(&subtitle_codec_name);
3592
    subtitle_stream_copy = 0;
3593
}
3594

    
3595
static int opt_new_stream(const char *opt, const char *arg)
3596
{
3597
    AVFormatContext *oc;
3598
    int file_idx = nb_output_files - 1;
3599
    if (nb_output_files <= 0) {
3600
        fprintf(stderr, "At least one output file must be specified\n");
3601
        ffmpeg_exit(1);
3602
    }
3603
    oc = output_files[file_idx];
3604

    
3605
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3606
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3607
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3608
    else av_assert0(0);
3609
    return 0;
3610
}
3611

    
3612
/* arg format is "output-stream-index:streamid-value". */
3613
static int opt_streamid(const char *opt, const char *arg)
3614
{
3615
    int idx;
3616
    char *p;
3617
    char idx_str[16];
3618

    
3619
    strncpy(idx_str, arg, sizeof(idx_str));
3620
    idx_str[sizeof(idx_str)-1] = '\0';
3621
    p = strchr(idx_str, ':');
3622
    if (!p) {
3623
        fprintf(stderr,
3624
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3625
                arg, opt);
3626
        ffmpeg_exit(1);
3627
    }
3628
    *p++ = '\0';
3629
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3630
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3631
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3632
    return 0;
3633
}
3634

    
3635
static void opt_output_file(const char *filename)
3636
{
3637
    AVFormatContext *oc;
3638
    int err, use_video, use_audio, use_subtitle;
3639
    int input_has_video, input_has_audio, input_has_subtitle;
3640
    AVFormatParameters params, *ap = &params;
3641
    AVOutputFormat *file_oformat;
3642
    AVMetadataTag *tag = NULL;
3643

    
3644
    if (!strcmp(filename, "-"))
3645
        filename = "pipe:";
3646

    
3647
    oc = avformat_alloc_context();
3648
    if (!oc) {
3649
        print_error(filename, AVERROR(ENOMEM));
3650
        ffmpeg_exit(1);
3651
    }
3652

    
3653
    if (last_asked_format) {
3654
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3655
        if (!file_oformat) {
3656
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3657
            ffmpeg_exit(1);
3658
        }
3659
        last_asked_format = NULL;
3660
    } else {
3661
        file_oformat = av_guess_format(NULL, filename, NULL);
3662
        if (!file_oformat) {
3663
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3664
                    filename);
3665
            ffmpeg_exit(1);
3666
        }
3667
    }
3668

    
3669
    oc->oformat = file_oformat;
3670
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3671

    
3672
    if (!strcmp(file_oformat->name, "ffm") &&
3673
        av_strstart(filename, "http:", NULL)) {
3674
        /* special case for files sent to ffserver: we get the stream
3675
           parameters from ffserver */
3676
        int err = read_ffserver_streams(oc, filename);
3677
        if (err < 0) {
3678
            print_error(filename, err);
3679
            ffmpeg_exit(1);
3680
        }
3681
    } else {
3682
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3683
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3684
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3685

    
3686
        /* disable if no corresponding type found and at least one
3687
           input file */
3688
        if (nb_input_files > 0) {
3689
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3690
                                         &input_has_subtitle);
3691
            if (!input_has_video)
3692
                use_video = 0;
3693
            if (!input_has_audio)
3694
                use_audio = 0;
3695
            if (!input_has_subtitle)
3696
                use_subtitle = 0;
3697
        }
3698

    
3699
        /* manual disable */
3700
        if (audio_disable)    use_audio    = 0;
3701
        if (video_disable)    use_video    = 0;
3702
        if (subtitle_disable) use_subtitle = 0;
3703

    
3704
        if (use_video)    new_video_stream(oc, nb_output_files);
3705
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3706
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3707

    
3708
        oc->timestamp = recording_timestamp;
3709

    
3710
        while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
3711
            av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
3712
        av_metadata_free(&metadata);
3713
    }
3714

    
3715
    output_files[nb_output_files++] = oc;
3716

    
3717
    /* check filename in case of an image number is expected */
3718
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3719
        if (!av_filename_number_test(oc->filename)) {
3720
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3721
            ffmpeg_exit(1);
3722
        }
3723
    }
3724

    
3725
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3726
        /* test if it already exists to avoid loosing precious files */
3727
        if (!file_overwrite &&
3728
            (strchr(filename, ':') == NULL ||
3729
             filename[1] == ':' ||
3730
             av_strstart(filename, "file:", NULL))) {
3731
            if (url_exist(filename)) {
3732
                if (!using_stdin) {
3733
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3734
                    fflush(stderr);
3735
                    if (!read_yesno()) {
3736
                        fprintf(stderr, "Not overwriting - exiting\n");
3737
                        ffmpeg_exit(1);
3738
                    }
3739
                }
3740
                else {
3741
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3742
                    ffmpeg_exit(1);
3743
                }
3744
            }
3745
        }
3746

    
3747
        /* open the file */
3748
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3749
            print_error(filename, err);
3750
            ffmpeg_exit(1);
3751
        }
3752
    }
3753

    
3754
    memset(ap, 0, sizeof(*ap));
3755
    if (av_set_parameters(oc, ap) < 0) {
3756
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3757
                oc->filename);
3758
        ffmpeg_exit(1);
3759
    }
3760

    
3761
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3762
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3763
    oc->loop_output = loop_output;
3764
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3765

    
3766
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3767

    
3768
    nb_streamid_map = 0;
3769
    av_freep(&forced_key_frames);
3770
}
3771

    
3772
/* same option as mencoder */
3773
static void opt_pass(const char *pass_str)
3774
{
3775
    int pass;
3776
    pass = atoi(pass_str);
3777
    if (pass != 1 && pass != 2) {
3778
        fprintf(stderr, "pass number can be only 1 or 2\n");
3779
        ffmpeg_exit(1);
3780
    }
3781
    do_pass = pass;
3782
}
3783

    
3784
static int64_t getutime(void)
3785
{
3786
#if HAVE_GETRUSAGE
3787
    struct rusage rusage;
3788

    
3789
    getrusage(RUSAGE_SELF, &rusage);
3790
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3791
#elif HAVE_GETPROCESSTIMES
3792
    HANDLE proc;
3793
    FILETIME c, e, k, u;
3794
    proc = GetCurrentProcess();
3795
    GetProcessTimes(proc, &c, &e, &k, &u);
3796
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3797
#else
3798
    return av_gettime();
3799
#endif
3800
}
3801

    
3802
static int64_t getmaxrss(void)
3803
{
3804
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3805
    struct rusage rusage;
3806
    getrusage(RUSAGE_SELF, &rusage);
3807
    return (int64_t)rusage.ru_maxrss * 1024;
3808
#elif HAVE_GETPROCESSMEMORYINFO
3809
    HANDLE proc;
3810
    PROCESS_MEMORY_COUNTERS memcounters;
3811
    proc = GetCurrentProcess();
3812
    memcounters.cb = sizeof(memcounters);
3813
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3814
    return memcounters.PeakPagefileUsage;
3815
#else
3816
    return 0;
3817
#endif
3818
}
3819

    
3820
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3821
{
3822
    int i;
3823
    const char *p = str;
3824
    for(i = 0;; i++) {
3825
        dest[i] = atoi(p);
3826
        if(i == 63)
3827
            break;
3828
        p = strchr(p, ',');
3829
        if(!p) {
3830
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3831
            ffmpeg_exit(1);
3832
        }
3833
        p++;
3834
    }
3835
}
3836

    
3837
static void opt_inter_matrix(const char *arg)
3838
{
3839
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3840
    parse_matrix_coeffs(inter_matrix, arg);
3841
}
3842

    
3843
static void opt_intra_matrix(const char *arg)
3844
{
3845
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3846
    parse_matrix_coeffs(intra_matrix, arg);
3847
}
3848

    
3849
static void show_usage(void)
3850
{
3851
    printf("Hyper fast Audio and Video encoder\n");
3852
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3853
    printf("\n");
3854
}
3855

    
3856
static void show_help(void)
3857
{
3858
    av_log_set_callback(log_callback_help);
3859
    show_usage();
3860
    show_help_options(options, "Main options:\n",
3861
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3862
    show_help_options(options, "\nAdvanced options:\n",
3863
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3864
                      OPT_EXPERT);
3865
    show_help_options(options, "\nVideo options:\n",
3866
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3867
                      OPT_VIDEO);
3868
    show_help_options(options, "\nAdvanced Video options:\n",
3869
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3870
                      OPT_VIDEO | OPT_EXPERT);
3871
    show_help_options(options, "\nAudio options:\n",
3872
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3873
                      OPT_AUDIO);
3874
    show_help_options(options, "\nAdvanced Audio options:\n",
3875
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3876
                      OPT_AUDIO | OPT_EXPERT);
3877
    show_help_options(options, "\nSubtitle options:\n",
3878
                      OPT_SUBTITLE | OPT_GRAB,
3879
                      OPT_SUBTITLE);
3880
    show_help_options(options, "\nAudio/Video grab options:\n",
3881
                      OPT_GRAB,
3882
                      OPT_GRAB);
3883
    printf("\n");
3884
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3885
    printf("\n");
3886
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3887
    printf("\n");
3888
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3889
}
3890

    
3891
static void opt_target(const char *arg)
3892
{
3893
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3894
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3895

    
3896
    if(!strncmp(arg, "pal-", 4)) {
3897
        norm = PAL;
3898
        arg += 4;
3899
    } else if(!strncmp(arg, "ntsc-", 5)) {
3900
        norm = NTSC;
3901
        arg += 5;
3902
    } else if(!strncmp(arg, "film-", 5)) {
3903
        norm = FILM;
3904
        arg += 5;
3905
    } else {
3906
        int fr;
3907
        /* Calculate FR via float to avoid int overflow */
3908
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3909
        if(fr == 25000) {
3910
            norm = PAL;
3911
        } else if((fr == 29970) || (fr == 23976)) {
3912
            norm = NTSC;
3913
        } else {
3914
            /* Try to determine PAL/NTSC by peeking in the input files */
3915
            if(nb_input_files) {
3916
                int i, j;
3917
                for(j = 0; j < nb_input_files; j++) {
3918
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3919
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3920
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3921
                            continue;
3922
                        fr = c->time_base.den * 1000 / c->time_base.num;
3923
                        if(fr == 25000) {
3924
                            norm = PAL;
3925
                            break;
3926
                        } else if((fr == 29970) || (fr == 23976)) {
3927
                            norm = NTSC;
3928
                            break;
3929
                        }
3930
                    }
3931
                    if(norm != UNKNOWN)
3932
                        break;
3933
                }
3934
            }
3935
        }
3936
        if(verbose && norm != UNKNOWN)
3937
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3938
    }
3939

    
3940
    if(norm == UNKNOWN) {
3941
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3942
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3943
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3944
        ffmpeg_exit(1);
3945
    }
3946

    
3947
    if(!strcmp(arg, "vcd")) {
3948

    
3949
        opt_video_codec("mpeg1video");
3950
        opt_audio_codec("mp2");
3951
        opt_format("vcd");
3952

    
3953
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3954
        opt_frame_rate(NULL, frame_rates[norm]);
3955
        opt_default("g", norm == PAL ? "15" : "18");
3956

    
3957
        opt_default("b", "1150000");
3958
        opt_default("maxrate", "1150000");
3959
        opt_default("minrate", "1150000");
3960
        opt_default("bufsize", "327680"); // 40*1024*8;
3961

    
3962
        opt_default("ab", "224000");
3963
        audio_sample_rate = 44100;
3964
        audio_channels = 2;
3965

    
3966
        opt_default("packetsize", "2324");
3967
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3968

    
3969
        /* We have to offset the PTS, so that it is consistent with the SCR.
3970
           SCR starts at 36000, but the first two packs contain only padding
3971
           and the first pack from the other stream, respectively, may also have
3972
           been written before.
3973
           So the real data starts at SCR 36000+3*1200. */
3974
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3975
    } else if(!strcmp(arg, "svcd")) {
3976

    
3977
        opt_video_codec("mpeg2video");
3978
        opt_audio_codec("mp2");
3979
        opt_format("svcd");
3980

    
3981
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3982
        opt_frame_rate(NULL, frame_rates[norm]);
3983
        opt_default("g", norm == PAL ? "15" : "18");
3984

    
3985
        opt_default("b", "2040000");
3986
        opt_default("maxrate", "2516000");
3987
        opt_default("minrate", "0"); //1145000;
3988
        opt_default("bufsize", "1835008"); //224*1024*8;
3989
        opt_default("flags", "+scan_offset");
3990

    
3991

    
3992
        opt_default("ab", "224000");
3993
        audio_sample_rate = 44100;
3994

    
3995
        opt_default("packetsize", "2324");
3996

    
3997
    } else if(!strcmp(arg, "dvd")) {
3998

    
3999
        opt_video_codec("mpeg2video");
4000
        opt_audio_codec("ac3");
4001
        opt_format("dvd");
4002

    
4003
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4004
        opt_frame_rate(NULL, frame_rates[norm]);
4005
        opt_default("g", norm == PAL ? "15" : "18");
4006

    
4007
        opt_default("b", "6000000");
4008
        opt_default("maxrate", "9000000");
4009
        opt_default("minrate", "0"); //1500000;
4010
        opt_default("bufsize", "1835008"); //224*1024*8;
4011

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

    
4015
        opt_default("ab", "448000");
4016
        audio_sample_rate = 48000;
4017

    
4018
    } else if(!strncmp(arg, "dv", 2)) {
4019

    
4020
        opt_format("dv");
4021

    
4022
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4023
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4024
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4025
        opt_frame_rate(NULL, frame_rates[norm]);
4026

    
4027
        audio_sample_rate = 48000;
4028
        audio_channels = 2;
4029

    
4030
    } else {
4031
        fprintf(stderr, "Unknown target: %s\n", arg);
4032
        ffmpeg_exit(1);
4033
    }
4034
}
4035

    
4036
static void opt_vstats_file (const char *arg)
4037
{
4038
    av_free (vstats_filename);
4039
    vstats_filename=av_strdup (arg);
4040
}
4041

    
4042
static void opt_vstats (void)
4043
{
4044
    char filename[40];
4045
    time_t today2 = time(NULL);
4046
    struct tm *today = localtime(&today2);
4047

    
4048
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4049
             today->tm_sec);
4050
    opt_vstats_file(filename);
4051
}
4052

    
4053
static int opt_bsf(const char *opt, const char *arg)
4054
{
4055
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4056
    AVBitStreamFilterContext **bsfp;
4057

    
4058
    if(!bsfc){
4059
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4060
        ffmpeg_exit(1);
4061
    }
4062

    
4063
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4064
          *opt == 'a' ? &audio_bitstream_filters :
4065
                        &subtitle_bitstream_filters;
4066
    while(*bsfp)
4067
        bsfp= &(*bsfp)->next;
4068

    
4069
    *bsfp= bsfc;
4070

    
4071
    return 0;
4072
}
4073

    
4074
static int opt_preset(const char *opt, const char *arg)
4075
{
4076
    FILE *f=NULL;
4077
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4078
    char *codec_name = *opt == 'v' ? video_codec_name :
4079
                       *opt == 'a' ? audio_codec_name :
4080
                                     subtitle_codec_name;
4081

    
4082
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4083
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4084
        ffmpeg_exit(1);
4085
    }
4086

    
4087
    while(!feof(f)){
4088
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4089
        if(line[0] == '#' && !e)
4090
            continue;
4091
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4092
        if(e){
4093
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4094
            ffmpeg_exit(1);
4095
        }
4096
        if(!strcmp(tmp, "acodec")){
4097
            opt_audio_codec(tmp2);
4098
        }else if(!strcmp(tmp, "vcodec")){
4099
            opt_video_codec(tmp2);
4100
        }else if(!strcmp(tmp, "scodec")){
4101
            opt_subtitle_codec(tmp2);
4102
        }else if(opt_default(tmp, tmp2) < 0){
4103
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4104
            ffmpeg_exit(1);
4105
        }
4106
    }
4107

    
4108
    fclose(f);
4109

    
4110
    return 0;
4111
}
4112

    
4113
static const OptionDef options[] = {
4114
    /* main options */
4115
#include "cmdutils_common_opts.h"
4116
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4117
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4118
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4119
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4120
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile[,metadata]:infile[,metadata]" },
4121
    { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4122
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4123
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4124
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4125
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4126
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4127
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4128
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4129
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4130
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4131
      "add timings for benchmarking" },
4132
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4133
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4134
      "dump each input packet" },
4135
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4136
      "when dumping packets, also dump the payload" },
4137
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4138
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4139
    { "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)", "" },
4140
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4141
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4142
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4143
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4144
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4145
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4146
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4147
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4148
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4149
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4150
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4151
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4152
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4153

    
4154
    /* video options */
4155
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4156
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4157
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4158
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4159
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4160
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4161
    { "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" },
4162
    { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4163
    { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4164
    { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4165
    { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4166
    { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4167
    { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4168
    { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4169
    { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4170
    { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4171
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4172
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4173
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4174
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4175
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4176
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4177
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4178
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4179
      "use same video quality as source (implies VBR)" },
4180
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4181
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4182
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4183
      "deinterlace pictures" },
4184
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4185
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4186
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4187
#if CONFIG_AVFILTER
4188
    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4189
#endif
4190
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4191
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4192
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4193
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4194
    { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4195
    { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4196
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4197
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4198
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4199
    { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4200
    { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4201

    
4202
    /* audio options */
4203
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4204
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4205
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4206
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4207
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4208
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4209
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4210
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4211
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4212
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4213
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4214
    { "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" },
4215

    
4216
    /* subtitle options */
4217
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4218
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4219
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4220
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4221
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4222

    
4223
    /* grab options */
4224
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4225
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4226
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4227

    
4228
    /* muxer options */
4229
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4230
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4231

    
4232
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4233
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4234
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4235

    
4236
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4237
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4238
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4239
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4240

    
4241
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4242
    { NULL, },
4243
};
4244

    
4245
int main(int argc, char **argv)
4246
{
4247
    int64_t ti;
4248

    
4249
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4250

    
4251
    avcodec_register_all();
4252
#if CONFIG_AVDEVICE
4253
    avdevice_register_all();
4254
#endif
4255
#if CONFIG_AVFILTER
4256
    avfilter_register_all();
4257
#endif
4258
    av_register_all();
4259

    
4260
#if HAVE_ISATTY
4261
    if(isatty(STDIN_FILENO))
4262
        url_set_interrupt_cb(decode_interrupt_cb);
4263
#endif
4264

    
4265
    init_opts();
4266

    
4267
    show_banner();
4268

    
4269
    /* parse options */
4270
    parse_options(argc, argv, options, opt_output_file);
4271

    
4272
    if(nb_output_files <= 0 && nb_input_files == 0) {
4273
        show_usage();
4274
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4275
        ffmpeg_exit(1);
4276
    }
4277

    
4278
    /* file converter / grab */
4279
    if (nb_output_files <= 0) {
4280
        fprintf(stderr, "At least one output file must be specified\n");
4281
        ffmpeg_exit(1);
4282
    }
4283

    
4284
    if (nb_input_files == 0) {
4285
        fprintf(stderr, "At least one input file must be specified\n");
4286
        ffmpeg_exit(1);
4287
    }
4288

    
4289
    ti = getutime();
4290
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4291
                  stream_maps, nb_stream_maps) < 0)
4292
        ffmpeg_exit(1);
4293
    ti = getutime() - ti;
4294
    if (do_benchmark) {
4295
        int maxrss = getmaxrss() / 1024;
4296
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4297
    }
4298

    
4299
    return ffmpeg_exit(0);
4300
}