Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 5d6e4c16

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 AVSampleFormat audio_sample_fmt = AV_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 AVSampleFormat *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 != AV_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)+AV_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(AV_SAMPLE_FMT_NONE,AV_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
            break;
2422
        }
2423

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

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

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

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

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

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

    
2477
    timer_start = av_gettime();
2478

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2618
    discard_packet:
2619
        av_free_packet(&pkt);
2620

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

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

    
2633
    term_exit();
2634

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2744
    opt_default(opt, arg);
2745

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

    
2749
    return 0;
2750
}
2751

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

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

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

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

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

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

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

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

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

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

    
2821
    return 0;
2822
}
2823

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2922
    return 0;
2923
}
2924

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3171
    ic->loop_input = loop_input;
3172

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

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

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

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

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

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

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

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

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

    
3280
    nb_input_files++;
3281

    
3282
    video_channel = 0;
3283

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

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

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

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

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

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

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

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

    
3360
    video_enc = st->codec;
3361

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

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

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

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

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

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

    
3399
        choose_pixel_fmt(st, codec);
3400

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3575
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3576

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3709
        oc->timestamp = recording_timestamp;
3710

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

    
3716
    output_files[nb_output_files++] = oc;
3717

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3992

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

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

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

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

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

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

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

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

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

    
4021
        opt_format("dv");
4022

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

    
4028
        audio_sample_rate = 48000;
4029
        audio_channels = 2;
4030

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

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

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

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

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

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

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

    
4070
    *bsfp= bsfc;
4071

    
4072
    return 0;
4073
}
4074

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

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

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

    
4109
    fclose(f);
4110

    
4111
    return 0;
4112
}
4113

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

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

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

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

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

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

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

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

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

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

    
4250
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4251

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

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

    
4266
    init_opts();
4267

    
4268
    show_banner();
4269

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

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

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

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

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

    
4300
    return ffmpeg_exit(0);
4301
}