Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 037be76e

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

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

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

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

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

    
82
#include "cmdutils.h"
83

    
84
#include "libavutil/avassert.h"
85

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

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

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

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

    
111
static const OptionDef options[];
112

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

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

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

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

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

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

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

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

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

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

    
194
static float mux_preload= 0.5;
195
static float mux_max_delay= 0.7;
196

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

    
223
static int rate_emu = 0;
224

    
225
static int  video_channel = 0;
226
static char *video_standard;
227

    
228
static int audio_volume = 256;
229

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

    
245
static float dts_delta_threshold = 10;
246

    
247
static unsigned int sws_flags = SWS_BICUBIC;
248

    
249
static int64_t timer_start;
250

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

    
255
static short *samples;
256

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

    
261
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
262

    
263
struct AVInputStream;
264

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

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

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

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

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

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

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

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

    
339
#if HAVE_TERMIOS_H
340

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

    
345
#if CONFIG_AVFILTER
346

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

    
357
    graph = avfilter_graph_alloc();
358

    
359
    snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
360
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
361
    ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
362
                                       "src", args, NULL, graph);
363
    if (ret < 0)
364
        return ret;
365
    ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
366
                                       "out", NULL, &ffsink_ctx, graph);
367
    if (ret < 0)
368
        return ret;
369
    last_filter = ist->input_video_filter;
370

    
371
    if (codec->width  != icodec->width || codec->height != icodec->height) {
372
        snprintf(args, 255, "%d:%d:flags=0x%X",
373
                 codec->width,
374
                 codec->height,
375
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
376
        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
377
                                                NULL, args, NULL, graph)) < 0)
378
            return ret;
379
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
380
            return ret;
381
        last_filter = filter;
382
    }
383

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

    
387
    if (vfilters) {
388
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
389
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
390

    
391
        outputs->name    = av_strdup("in");
392
        outputs->filter_ctx = last_filter;
393
        outputs->pad_idx = 0;
394
        outputs->next    = NULL;
395

    
396
        inputs->name    = av_strdup("out");
397
        inputs->filter_ctx = ist->output_video_filter;
398
        inputs->pad_idx = 0;
399
        inputs->next    = NULL;
400

    
401
        if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
402
            return ret;
403
        av_freep(&vfilters);
404
    } else {
405
        if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
406
            return ret;
407
    }
408

    
409
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
410
        return ret;
411

    
412
    codec->width  = ist->output_video_filter->inputs[0]->w;
413
    codec->height = ist->output_video_filter->inputs[0]->h;
414

    
415
    return 0;
416
}
417
#endif /* CONFIG_AVFILTER */
418

    
419
static void term_exit(void)
420
{
421
    av_log(NULL, AV_LOG_QUIET, "");
422
#if HAVE_TERMIOS_H
423
    tcsetattr (0, TCSANOW, &oldtty);
424
#endif
425
}
426

    
427
static volatile int received_sigterm = 0;
428

    
429
static void
430
sigterm_handler(int sig)
431
{
432
    received_sigterm = sig;
433
    term_exit();
434
}
435

    
436
static void term_init(void)
437
{
438
#if HAVE_TERMIOS_H
439
    struct termios tty;
440

    
441
    tcgetattr (0, &tty);
442
    oldtty = tty;
443
    atexit(term_exit);
444

    
445
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
446
                          |INLCR|IGNCR|ICRNL|IXON);
447
    tty.c_oflag |= OPOST;
448
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
449
    tty.c_cflag &= ~(CSIZE|PARENB);
450
    tty.c_cflag |= CS8;
451
    tty.c_cc[VMIN] = 1;
452
    tty.c_cc[VTIME] = 0;
453

    
454
    tcsetattr (0, TCSANOW, &tty);
455
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
456
#endif
457

    
458
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
459
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
460
#ifdef SIGXCPU
461
    signal(SIGXCPU, sigterm_handler);
462
#endif
463
}
464

    
465
/* read a key without blocking */
466
static int read_key(void)
467
{
468
#if HAVE_TERMIOS_H
469
    int n = 1;
470
    unsigned char ch;
471
    struct timeval tv;
472
    fd_set rfds;
473

    
474
    FD_ZERO(&rfds);
475
    FD_SET(0, &rfds);
476
    tv.tv_sec = 0;
477
    tv.tv_usec = 0;
478
    n = select(1, &rfds, NULL, NULL, &tv);
479
    if (n > 0) {
480
        n = read(0, &ch, 1);
481
        if (n == 1)
482
            return ch;
483

    
484
        return n;
485
    }
486
#elif HAVE_CONIO_H
487
    if(kbhit())
488
        return(getch());
489
#endif
490
    return -1;
491
}
492

    
493
static int decode_interrupt_cb(void)
494
{
495
    return q_pressed || (q_pressed = read_key() == 'q');
496
}
497

    
498
static int ffmpeg_exit(int ret)
499
{
500
    int i;
501

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

    
530
    av_free(intra_matrix);
531
    av_free(inter_matrix);
532

    
533
    if (vstats_file)
534
        fclose(vstats_file);
535
    av_free(vstats_filename);
536

    
537
    av_free(opt_names);
538
    av_free(streamid_map);
539
    av_free(input_codecs);
540
    av_free(output_codecs);
541
    av_free(stream_maps);
542
    av_free(meta_data_maps);
543

    
544
    av_free(video_codec_name);
545
    av_free(audio_codec_name);
546
    av_free(subtitle_codec_name);
547

    
548
    av_free(video_standard);
549

    
550
    uninit_opts();
551
    av_free(audio_buf);
552
    av_free(audio_out);
553
    allocated_audio_buf_size= allocated_audio_out_size= 0;
554
    av_free(samples);
555

    
556
#if CONFIG_AVFILTER
557
    avfilter_uninit();
558
#endif
559

    
560
    if (received_sigterm) {
561
        fprintf(stderr,
562
            "Received signal %d: terminating.\n",
563
            (int) received_sigterm);
564
        exit (255);
565
    }
566

    
567
    exit(ret); /* not all OS-es handle main() return value */
568
    return ret;
569
}
570

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

    
591
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
592
{
593
    if(codec && codec->sample_fmts){
594
        const enum AVSampleFormat *p= codec->sample_fmts;
595
        for(; *p!=-1; p++){
596
            if(*p == st->codec->sample_fmt)
597
                break;
598
        }
599
        if(*p == -1)
600
            st->codec->sample_fmt = codec->sample_fmts[0];
601
    }
602
}
603

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

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

    
641
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
642
{
643
    int idx = oc->nb_streams - 1;
644
    AVOutputStream *ost;
645

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

    
662
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
663
{
664
    int i, err;
665
    AVFormatContext *ic;
666
    int nopts = 0;
667

    
668
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
669
    if (err < 0)
670
        return err;
671
    /* copy stream format */
672
    s->nb_streams = 0;
673
    for(i=0;i<ic->nb_streams;i++) {
674
        AVStream *st;
675
        AVCodec *codec;
676

    
677
        s->nb_streams++;
678

    
679
        // FIXME: a more elegant solution is needed
680
        st = av_mallocz(sizeof(AVStream));
681
        memcpy(st, ic->streams[i], sizeof(AVStream));
682
        st->codec = avcodec_alloc_context();
683
        if (!st->codec) {
684
            print_error(filename, AVERROR(ENOMEM));
685
            ffmpeg_exit(1);
686
        }
687
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
688
        s->streams[i] = st;
689

    
690
        codec = avcodec_find_encoder(st->codec->codec_id);
691
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
692
            if (audio_stream_copy) {
693
                st->stream_copy = 1;
694
            } else
695
                choose_sample_fmt(st, codec);
696
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
697
            if (video_stream_copy) {
698
                st->stream_copy = 1;
699
            } else
700
                choose_pixel_fmt(st, codec);
701
        }
702

    
703
        if(!st->codec->thread_count)
704
            st->codec->thread_count = 1;
705
        if(st->codec->thread_count>1)
706
            avcodec_thread_init(st->codec, st->codec->thread_count);
707

    
708
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
709
            nopts = 1;
710

    
711
        new_output_stream(s, nb_output_files);
712
    }
713

    
714
    if (!nopts)
715
        s->timestamp = av_gettime();
716

    
717
    av_close_input_file(ic);
718
    return 0;
719
}
720

    
721
static double
722
get_sync_ipts(const AVOutputStream *ost)
723
{
724
    const AVInputStream *ist = ost->sync_ist;
725
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
726
}
727

    
728
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
729
    int ret;
730

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

    
750
        bsfc= bsfc->next;
751
    }
752

    
753
    ret= av_interleaved_write_frame(s, pkt);
754
    if(ret < 0){
755
        print_error("av_interleaved_write_frame()", ret);
756
        ffmpeg_exit(1);
757
    }
758
}
759

    
760
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
761

    
762
static void do_audio_out(AVFormatContext *s,
763
                         AVOutputStream *ost,
764
                         AVInputStream *ist,
765
                         unsigned char *buf, int size)
766
{
767
    uint8_t *buftmp;
768
    int64_t audio_out_size, audio_buf_size;
769
    int64_t allocated_for_size= size;
770

    
771
    int size_out, frame_bytes, ret;
772
    AVCodecContext *enc= ost->st->codec;
773
    AVCodecContext *dec= ist->st->codec;
774
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
775
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
776
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
777

    
778
need_realloc:
779
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
780
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
781
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
782
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
783
    audio_buf_size*= osize*enc->channels;
784

    
785
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
786
    if(coded_bps > 8*osize)
787
        audio_out_size= audio_out_size * coded_bps / (8*osize);
788
    audio_out_size += FF_MIN_BUFFER_SIZE;
789

    
790
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
791
        fprintf(stderr, "Buffer sizes too large\n");
792
        ffmpeg_exit(1);
793
    }
794

    
795
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
796
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
797
    if (!audio_buf || !audio_out){
798
        fprintf(stderr, "Out of memory in do_audio_out\n");
799
        ffmpeg_exit(1);
800
    }
801

    
802
    if (enc->channels != dec->channels)
803
        ost->audio_resample = 1;
804

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

    
820
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
821
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
822
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
823
        if (ost->reformat_ctx)
824
            av_audio_convert_free(ost->reformat_ctx);
825
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
826
                                                   dec->sample_fmt, 1, NULL, 0);
827
        if (!ost->reformat_ctx) {
828
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
829
                av_get_sample_fmt_name(dec->sample_fmt),
830
                av_get_sample_fmt_name(enc->sample_fmt));
831
            ffmpeg_exit(1);
832
        }
833
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
834
    }
835

    
836
    if(audio_sync_method){
837
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
838
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
839
        double idelta= delta*dec->sample_rate / enc->sample_rate;
840
        int byte_delta= ((int)idelta)*2*dec->channels;
841

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

    
858
                    if(byte_delta > allocated_for_size - size){
859
                        allocated_for_size= byte_delta + (int64_t)size;
860
                        goto need_realloc;
861
                    }
862
                    ist->is_start=0;
863

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

    
884
    if (ost->audio_resample) {
885
        buftmp = audio_buf;
886
        size_out = audio_resample(ost->resample,
887
                                  (short *)buftmp, (short *)buf,
888
                                  size / (dec->channels * isize));
889
        size_out = size_out * enc->channels * osize;
890
    } else {
891
        buftmp = buf;
892
        size_out = size;
893
    }
894

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

    
911
    /* now encode as many frames as possible */
912
    if (enc->frame_size > 1) {
913
        /* output resampled raw samples */
914
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
915
            fprintf(stderr, "av_fifo_realloc2() failed\n");
916
            ffmpeg_exit(1);
917
        }
918
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
919

    
920
        frame_bytes = enc->frame_size * osize * enc->channels;
921

    
922
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
923
            AVPacket pkt;
924
            av_init_packet(&pkt);
925

    
926
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
927

    
928
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
929

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

    
945
            ost->sync_opts += enc->frame_size;
946
        }
947
    } else {
948
        AVPacket pkt;
949
        av_init_packet(&pkt);
950

    
951
        ost->sync_opts += size_out / (osize * enc->channels);
952

    
953
        /* output a pcm frame */
954
        /* determine the size of the coded buffer */
955
        size_out /= osize;
956
        if (coded_bps)
957
            size_out = size_out*coded_bps/8;
958

    
959
        if(size_out > audio_out_size){
960
            fprintf(stderr, "Internal error, buffer size too small\n");
961
            ffmpeg_exit(1);
962
        }
963

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

    
982
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
983
{
984
    AVCodecContext *dec;
985
    AVPicture *picture2;
986
    AVPicture picture_tmp;
987
    uint8_t *buf = 0;
988

    
989
    dec = ist->st->codec;
990

    
991
    /* deinterlace : must be done before any resize */
992
    if (do_deinterlace) {
993
        int size;
994

    
995
        /* create temporary picture */
996
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
997
        buf = av_malloc(size);
998
        if (!buf)
999
            return;
1000

    
1001
        picture2 = &picture_tmp;
1002
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1003

    
1004
        if(avpicture_deinterlace(picture2, picture,
1005
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1006
            /* if error, do not deinterlace */
1007
            fprintf(stderr, "Deinterlacing failed\n");
1008
            av_free(buf);
1009
            buf = NULL;
1010
            picture2 = picture;
1011
        }
1012
    } else {
1013
        picture2 = picture;
1014
    }
1015

    
1016
    if (picture != picture2)
1017
        *picture = *picture2;
1018
    *bufp = buf;
1019
}
1020

    
1021
/* we begin to correct av delay at this threshold */
1022
#define AV_DELAY_MAX 0.100
1023

    
1024
static void do_subtitle_out(AVFormatContext *s,
1025
                            AVOutputStream *ost,
1026
                            AVInputStream *ist,
1027
                            AVSubtitle *sub,
1028
                            int64_t pts)
1029
{
1030
    static uint8_t *subtitle_out = NULL;
1031
    int subtitle_out_max_size = 1024 * 1024;
1032
    int subtitle_out_size, nb, i;
1033
    AVCodecContext *enc;
1034
    AVPacket pkt;
1035

    
1036
    if (pts == AV_NOPTS_VALUE) {
1037
        fprintf(stderr, "Subtitle packets must have a pts\n");
1038
        if (exit_on_error)
1039
            ffmpeg_exit(1);
1040
        return;
1041
    }
1042

    
1043
    enc = ost->st->codec;
1044

    
1045
    if (!subtitle_out) {
1046
        subtitle_out = av_malloc(subtitle_out_max_size);
1047
    }
1048

    
1049
    /* Note: DVB subtitle need one packet to draw them and one other
1050
       packet to clear them */
1051
    /* XXX: signal it in the codec context ? */
1052
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1053
        nb = 2;
1054
    else
1055
        nb = 1;
1056

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

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

    
1087
static int bit_buffer_size= 1024*256;
1088
static uint8_t *bit_buffer= NULL;
1089

    
1090
static void do_video_out(AVFormatContext *s,
1091
                         AVOutputStream *ost,
1092
                         AVInputStream *ist,
1093
                         AVFrame *in_picture,
1094
                         int *frame_size)
1095
{
1096
    int nb_frames, i, ret;
1097
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1098
    AVCodecContext *enc, *dec;
1099
    double sync_ipts;
1100

    
1101
    enc = ost->st->codec;
1102
    dec = ist->st->codec;
1103

    
1104
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1105

    
1106
    /* by default, we output a single frame */
1107
    nb_frames = 1;
1108

    
1109
    *frame_size = 0;
1110

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

    
1136
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1137
    if (nb_frames <= 0)
1138
        return;
1139

    
1140
    formatted_picture = in_picture;
1141
    final_picture = formatted_picture;
1142
    padding_src = formatted_picture;
1143
    resampling_dst = &ost->pict_tmp;
1144

    
1145
    if (   ost->resample_height != ist->st->codec->height
1146
        || ost->resample_width  != ist->st->codec->width
1147
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1148

    
1149
        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));
1150
        if(!ost->video_resample)
1151
            ffmpeg_exit(1);
1152
    }
1153

    
1154
#if !CONFIG_AVFILTER
1155
    if (ost->video_resample) {
1156
        padding_src = NULL;
1157
        final_picture = &ost->pict_tmp;
1158
        if(  ost->resample_height != ist->st->codec->height
1159
          || ost->resample_width  != ist->st->codec->width
1160
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1161

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

    
1183
    /* duplicates frame if needed */
1184
    for(i=0;i<nb_frames;i++) {
1185
        AVPacket pkt;
1186
        av_init_packet(&pkt);
1187
        pkt.stream_index= ost->index;
1188

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

    
1200
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1201
            enc->coded_frame = old_frame;
1202
        } else {
1203
            AVFrame big_picture;
1204

    
1205
            big_picture= *final_picture;
1206
            /* better than nothing: use input picture interlaced
1207
               settings */
1208
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1209
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1210
                if(top_field_first == -1)
1211
                    big_picture.top_field_first = in_picture->top_field_first;
1212
                else
1213
                    big_picture.top_field_first = top_field_first;
1214
            }
1215

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

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

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

    
1265
static double psnr(double d){
1266
    return -10.0*log(d)/log(10.0);
1267
}
1268

    
1269
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1270
                           int frame_size)
1271
{
1272
    AVCodecContext *enc;
1273
    int frame_number;
1274
    double ti1, bitrate, avg_bitrate;
1275

    
1276
    /* this is executed just the first time do_video_stats is called */
1277
    if (!vstats_file) {
1278
        vstats_file = fopen(vstats_filename, "w");
1279
        if (!vstats_file) {
1280
            perror("fopen");
1281
            ffmpeg_exit(1);
1282
        }
1283
    }
1284

    
1285
    enc = ost->st->codec;
1286
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1287
        frame_number = ost->frame_number;
1288
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1289
        if (enc->flags&CODEC_FLAG_PSNR)
1290
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1291

    
1292
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1293
        /* compute pts value */
1294
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1295
        if (ti1 < 0.01)
1296
            ti1 = 0.01;
1297

    
1298
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1299
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1300
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1301
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1302
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1303
    }
1304
}
1305

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

    
1320
    if (!is_last_report) {
1321
        int64_t cur_time;
1322
        /* display the report every 0.5 seconds */
1323
        cur_time = av_gettime();
1324
        if (last_time == -1) {
1325
            last_time = cur_time;
1326
            return;
1327
        }
1328
        if ((cur_time - last_time) < 500000)
1329
            return;
1330
        last_time = cur_time;
1331
    }
1332

    
1333

    
1334
    oc = output_files[0];
1335

    
1336
    total_size = url_fsize(oc->pb);
1337
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1338
        total_size= url_ftell(oc->pb);
1339

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

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

    
1400
    if (verbose || is_last_report) {
1401
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1402

    
1403
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1404
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1405
            (double)total_size / 1024, ti1, bitrate);
1406

    
1407
        if (nb_frames_dup || nb_frames_drop)
1408
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1409
                  nb_frames_dup, nb_frames_drop);
1410

    
1411
        if (verbose >= 0)
1412
            fprintf(stderr, "%s    \r", buf);
1413

    
1414
        fflush(stderr);
1415
    }
1416

    
1417
    if (is_last_report && verbose >= 0){
1418
        int64_t raw= audio_size + video_size + extra_size;
1419
        fprintf(stderr, "\n");
1420
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1421
                video_size/1024.0,
1422
                audio_size/1024.0,
1423
                extra_size/1024.0,
1424
                100.0*(total_size - raw)/raw
1425
        );
1426
    }
1427
}
1428

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

    
1447
    AVPacket avpkt;
1448
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1449

    
1450
    if(ist->next_pts == AV_NOPTS_VALUE)
1451
        ist->next_pts= ist->pts;
1452

    
1453
    if (pkt == NULL) {
1454
        /* EOF handling */
1455
        av_init_packet(&avpkt);
1456
        avpkt.data = NULL;
1457
        avpkt.size = 0;
1458
        goto handle_eof;
1459
    } else {
1460
        avpkt = *pkt;
1461
    }
1462

    
1463
    if(pkt->dts != AV_NOPTS_VALUE)
1464
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1465
    if(pkt->pts != AV_NOPTS_VALUE)
1466
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1467

    
1468
    //while we have more to decode or while the decoder did output something on EOF
1469
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1470
        uint8_t *data_buf, *decoded_data_buf;
1471
        int data_size, decoded_data_size;
1472
    handle_eof:
1473
        ist->pts= ist->next_pts;
1474

    
1475
        if(avpkt.size && avpkt.size != pkt->size &&
1476
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1477
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1478
            ist->showed_multi_packet_warning=1;
1479
        }
1480

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

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

    
1573
        buffer_to_free = NULL;
1574
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1575
            pre_process_video_frame(ist, (AVPicture *)&picture,
1576
                                    &buffer_to_free);
1577
        }
1578

    
1579
#if CONFIG_AVFILTER
1580
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1581
            // add it to be filtered
1582
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1583
                                     ist->pts,
1584
                                     ist->st->codec->sample_aspect_ratio);
1585
        }
1586
#endif
1587

    
1588
        // preprocess audio (volume)
1589
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1590
            if (audio_volume != 256) {
1591
                short *volp;
1592
                volp = samples;
1593
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1594
                    int v = ((*volp) * audio_volume + 128) >> 8;
1595
                    if (v < -32768) v = -32768;
1596
                    if (v >  32767) v = 32767;
1597
                    *volp++ = v;
1598
                }
1599
            }
1600
        }
1601

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

    
1627
                ost = ost_table[i];
1628
                if (ost->source_index == ist_index) {
1629
                    os = output_files[ost->file_index];
1630

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

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

    
1661
                        av_init_packet(&opkt);
1662

    
1663
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1664
                            continue;
1665

    
1666
                        /* no reencoding needed : output the packet directly */
1667
                        /* force the input stream PTS */
1668

    
1669
                        avcodec_get_frame_defaults(&avframe);
1670
                        ost->st->codec->coded_frame= &avframe;
1671
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1672

    
1673
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1674
                            audio_size += data_size;
1675
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1676
                            video_size += data_size;
1677
                            ost->sync_opts++;
1678
                        }
1679

    
1680
                        opkt.stream_index= ost->index;
1681
                        if(pkt->pts != AV_NOPTS_VALUE)
1682
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1683
                        else
1684
                            opkt.pts= AV_NOPTS_VALUE;
1685

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

    
1692
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1693
                        opkt.flags= pkt->flags;
1694

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

    
1707
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1708
                        ost->st->codec->frame_number++;
1709
                        ost->frame_number++;
1710
                        av_free_packet(&opkt);
1711
                    }
1712
                }
1713
            }
1714

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

    
1741
        for(i=0;i<nb_ostreams;i++) {
1742
            ost = ost_table[i];
1743
            if (ost->source_index == ist_index) {
1744
                AVCodecContext *enc= ost->st->codec;
1745
                os = output_files[ost->file_index];
1746

    
1747
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1748
                    continue;
1749
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1750
                    continue;
1751

    
1752
                if (ost->encoding_needed) {
1753
                    for(;;) {
1754
                        AVPacket pkt;
1755
                        int fifo_bytes;
1756
                        av_init_packet(&pkt);
1757
                        pkt.stream_index= ost->index;
1758

    
1759
                        switch(ost->st->codec->codec_type) {
1760
                        case AVMEDIA_TYPE_AUDIO:
1761
                            fifo_bytes = av_fifo_size(ost->fifo);
1762
                            ret = 0;
1763
                            /* encode any samples remaining in fifo */
1764
                            if (fifo_bytes > 0) {
1765
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1766
                                int fs_tmp = enc->frame_size;
1767

    
1768
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1769
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1770
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1771
                                } else { /* pad */
1772
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1773
                                    if (allocated_audio_buf_size < frame_bytes)
1774
                                        ffmpeg_exit(1);
1775
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1776
                                }
1777

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

    
1810
                        if(ret<=0)
1811
                            break;
1812
                        pkt.data= bit_buffer;
1813
                        pkt.size= ret;
1814
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1815
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1816
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1817
                    }
1818
                }
1819
            }
1820
        }
1821
    }
1822

    
1823
    return 0;
1824
 fail_decode:
1825
    return -1;
1826
}
1827

    
1828
static void print_sdp(AVFormatContext **avc, int n)
1829
{
1830
    char sdp[2048];
1831

    
1832
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1833
    printf("SDP:\n%s\n", sdp);
1834
    fflush(stdout);
1835
}
1836

    
1837
static int copy_chapters(int infile, int outfile)
1838
{
1839
    AVFormatContext *is = input_files[infile];
1840
    AVFormatContext *os = output_files[outfile];
1841
    int i;
1842

    
1843
    for (i = 0; i < is->nb_chapters; i++) {
1844
        AVChapter *in_ch = is->chapters[i], *out_ch;
1845
        AVMetadataTag *t = NULL;
1846
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1847
                                      AV_TIME_BASE_Q, in_ch->time_base);
1848
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1849
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1850

    
1851

    
1852
        if (in_ch->end < ts_off)
1853
            continue;
1854
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1855
            break;
1856

    
1857
        out_ch = av_mallocz(sizeof(AVChapter));
1858
        if (!out_ch)
1859
            return AVERROR(ENOMEM);
1860

    
1861
        out_ch->id        = in_ch->id;
1862
        out_ch->time_base = in_ch->time_base;
1863
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1864
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1865

    
1866
        if (metadata_chapters_autocopy)
1867
            while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1868
                av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1869

    
1870
        os->nb_chapters++;
1871
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1872
        if (!os->chapters)
1873
            return AVERROR(ENOMEM);
1874
        os->chapters[os->nb_chapters - 1] = out_ch;
1875
    }
1876
    return 0;
1877
}
1878

    
1879
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1880
                                    AVCodecContext *avctx)
1881
{
1882
    char *p;
1883
    int n = 1, i;
1884
    int64_t t;
1885

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

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

    
1923
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1924
    if (!file_table)
1925
        goto fail;
1926

    
1927
    /* input stream init */
1928
    j = 0;
1929
    for(i=0;i<nb_input_files;i++) {
1930
        is = input_files[i];
1931
        file_table[i].ist_index = j;
1932
        file_table[i].nb_streams = is->nb_streams;
1933
        j += is->nb_streams;
1934
    }
1935
    nb_istreams = j;
1936

    
1937
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1938
    if (!ist_table)
1939
        goto fail;
1940

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

    
1958
            if (rate_emu) {
1959
                ist->start = av_gettime();
1960
            }
1961
        }
1962
    }
1963

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

    
1982
    /* Sanity check the mapping args -- do the input files & streams exist? */
1983
    for(i=0;i<nb_stream_maps;i++) {
1984
        int fi = stream_maps[i].file_index;
1985
        int si = stream_maps[i].stream_index;
1986

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

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

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

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

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

    
2086
    /* for each output stream, we compute the right encoding parameters */
2087
    for(i=0;i<nb_ostreams;i++) {
2088
        AVMetadataTag *t = NULL;
2089
        ost = ost_table[i];
2090
        os = output_files[ost->file_index];
2091
        ist = ist_table[ost->source_index];
2092

    
2093
        codec = ost->st->codec;
2094
        icodec = ist->st->codec;
2095

    
2096
        if (metadata_streams_autocopy)
2097
            while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2098
                av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2099
            }
2100

    
2101
        ost->st->disposition = ist->st->disposition;
2102
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2103
        codec->chroma_sample_location = icodec->chroma_sample_location;
2104

    
2105
        if (ost->st->stream_copy) {
2106
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2107

    
2108
            if (extra_size > INT_MAX)
2109
                goto fail;
2110

    
2111
            /* if stream_copy is selected, no need to decode or encode */
2112
            codec->codec_id = icodec->codec_id;
2113
            codec->codec_type = icodec->codec_type;
2114

    
2115
            if(!codec->codec_tag){
2116
                if(   !os->oformat->codec_tag
2117
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2118
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2119
                    codec->codec_tag = icodec->codec_tag;
2120
            }
2121

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

    
2207
#if !CONFIG_AVFILTER
2208
                    ost->original_height = icodec->height;
2209
                    ost->original_width  = icodec->width;
2210
#endif
2211
                    codec->bits_per_raw_sample= 0;
2212
                }
2213
                ost->resample_height = icodec->height;
2214
                ost->resample_width  = icodec->width;
2215
                ost->resample_pix_fmt= icodec->pix_fmt;
2216
                ost->encoding_needed = 1;
2217
                ist->decoding_needed = 1;
2218

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

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

    
2267
    if (!bit_buffer)
2268
        bit_buffer = av_malloc(bit_buffer_size);
2269
    if (!bit_buffer) {
2270
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2271
                bit_buffer_size);
2272
        ret = AVERROR(ENOMEM);
2273
        goto fail;
2274
    }
2275

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

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

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

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

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

    
2359
        int out_file_index = meta_data_maps[i][0].file;
2360
        int in_file_index = meta_data_maps[i][1].file;
2361
        if (in_file_index < 0 || out_file_index < 0)
2362
            continue;
2363
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2364
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2365

    
2366
        files[0] = output_files[out_file_index];
2367
        files[1] = input_files[in_file_index];
2368

    
2369
        for (j = 0; j < 2; j++) {
2370
            AVMetaDataMap *map = &meta_data_maps[i][j];
2371

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

    
2391
        mtag=NULL;
2392
        while((mtag=av_metadata_get(*meta[1], "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2393
            av_metadata_set2(meta[0], mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2394
    }
2395

    
2396
    /* copy global metadata by default */
2397
    if (metadata_global_autocopy) {
2398
        AVMetadataTag *t = NULL;
2399

    
2400
        while ((t = av_metadata_get(input_files[0]->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
2401
            for (i = 0; i < nb_output_files; i++)
2402
                av_metadata_set2(&output_files[i]->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2403
    }
2404

    
2405
    /* copy chapters according to chapter maps */
2406
    for (i = 0; i < nb_chapter_maps; i++) {
2407
        int infile  = chapter_maps[i].in_file;
2408
        int outfile = chapter_maps[i].out_file;
2409

    
2410
        if (infile < 0 || outfile < 0)
2411
            continue;
2412
        if (infile >= nb_input_files) {
2413
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2414
            ret = AVERROR(EINVAL);
2415
            goto dump_format;
2416
        }
2417
        if (outfile >= nb_output_files) {
2418
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2419
            ret = AVERROR(EINVAL);
2420
            goto dump_format;
2421
        }
2422
        copy_chapters(infile, outfile);
2423
    }
2424

    
2425
    /* copy chapters from the first input file that has them*/
2426
    if (!nb_chapter_maps)
2427
        for (i = 0; i < nb_input_files; i++) {
2428
            if (!input_files[i]->nb_chapters)
2429
                continue;
2430

    
2431
            for (j = 0; j < nb_output_files; j++)
2432
                if ((ret = copy_chapters(i, j)) < 0)
2433
                    goto dump_format;
2434
            break;
2435
        }
2436

    
2437
    /* open files and write file headers */
2438
    for(i=0;i<nb_output_files;i++) {
2439
        os = output_files[i];
2440
        if (av_write_header(os) < 0) {
2441
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2442
            ret = AVERROR(EINVAL);
2443
            goto dump_format;
2444
        }
2445
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2446
            want_sdp = 0;
2447
        }
2448
    }
2449

    
2450
 dump_format:
2451
    /* dump the file output parameters - cannot be done before in case
2452
       of stream copy */
2453
    for(i=0;i<nb_output_files;i++) {
2454
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2455
    }
2456

    
2457
    /* dump the stream mapping */
2458
    if (verbose >= 0) {
2459
        fprintf(stderr, "Stream mapping:\n");
2460
        for(i=0;i<nb_ostreams;i++) {
2461
            ost = ost_table[i];
2462
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2463
                    ist_table[ost->source_index]->file_index,
2464
                    ist_table[ost->source_index]->index,
2465
                    ost->file_index,
2466
                    ost->index);
2467
            if (ost->sync_ist != ist_table[ost->source_index])
2468
                fprintf(stderr, " [sync #%d.%d]",
2469
                        ost->sync_ist->file_index,
2470
                        ost->sync_ist->index);
2471
            fprintf(stderr, "\n");
2472
        }
2473
    }
2474

    
2475
    if (ret) {
2476
        fprintf(stderr, "%s\n", error);
2477
        goto fail;
2478
    }
2479

    
2480
    if (want_sdp) {
2481
        print_sdp(output_files, nb_output_files);
2482
    }
2483

    
2484
    if (!using_stdin && verbose >= 0) {
2485
        fprintf(stderr, "Press [q] to stop encoding\n");
2486
        url_set_interrupt_cb(decode_interrupt_cb);
2487
    }
2488
    term_init();
2489

    
2490
    timer_start = av_gettime();
2491

    
2492
    for(; received_sigterm == 0;) {
2493
        int file_index, ist_index;
2494
        AVPacket pkt;
2495
        double ipts_min;
2496
        double opts_min;
2497

    
2498
    redo:
2499
        ipts_min= 1e100;
2500
        opts_min= 1e100;
2501
        /* if 'q' pressed, exits */
2502
        if (!using_stdin) {
2503
            if (q_pressed)
2504
                break;
2505
            /* read_key() returns 0 on EOF */
2506
            key = read_key();
2507
            if (key == 'q')
2508
                break;
2509
        }
2510

    
2511
        /* select the stream that we must read now by looking at the
2512
           smallest output pts */
2513
        file_index = -1;
2514
        for(i=0;i<nb_ostreams;i++) {
2515
            double ipts, opts;
2516
            ost = ost_table[i];
2517
            os = output_files[ost->file_index];
2518
            ist = ist_table[ost->source_index];
2519
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2520
                continue;
2521
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2522
            ipts = (double)ist->pts;
2523
            if (!file_table[ist->file_index].eof_reached){
2524
                if(ipts < ipts_min) {
2525
                    ipts_min = ipts;
2526
                    if(input_sync ) file_index = ist->file_index;
2527
                }
2528
                if(opts < opts_min) {
2529
                    opts_min = opts;
2530
                    if(!input_sync) file_index = ist->file_index;
2531
                }
2532
            }
2533
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2534
                file_index= -1;
2535
                break;
2536
            }
2537
        }
2538
        /* if none, if is finished */
2539
        if (file_index < 0) {
2540
            if(no_packet_count){
2541
                no_packet_count=0;
2542
                memset(no_packet, 0, sizeof(no_packet));
2543
                usleep(10000);
2544
                continue;
2545
            }
2546
            break;
2547
        }
2548

    
2549
        /* finish if limit size exhausted */
2550
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2551
            break;
2552

    
2553
        /* read a frame from it and output it in the fifo */
2554
        is = input_files[file_index];
2555
        ret= av_read_frame(is, &pkt);
2556
        if(ret == AVERROR(EAGAIN)){
2557
            no_packet[file_index]=1;
2558
            no_packet_count++;
2559
            continue;
2560
        }
2561
        if (ret < 0) {
2562
            file_table[file_index].eof_reached = 1;
2563
            if (opt_shortest)
2564
                break;
2565
            else
2566
                continue;
2567
        }
2568

    
2569
        no_packet_count=0;
2570
        memset(no_packet, 0, sizeof(no_packet));
2571

    
2572
        if (do_pkt_dump) {
2573
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2574
        }
2575
        /* the following test is needed in case new streams appear
2576
           dynamically in stream : we ignore them */
2577
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2578
            goto discard_packet;
2579
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2580
        ist = ist_table[ist_index];
2581
        if (ist->discard)
2582
            goto discard_packet;
2583

    
2584
        if (pkt.dts != AV_NOPTS_VALUE)
2585
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2586
        if (pkt.pts != AV_NOPTS_VALUE)
2587
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2588

    
2589
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2590
            && input_files_ts_scale[file_index][pkt.stream_index]){
2591
            if(pkt.pts != AV_NOPTS_VALUE)
2592
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2593
            if(pkt.dts != AV_NOPTS_VALUE)
2594
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2595
        }
2596

    
2597
//        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);
2598
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2599
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2600
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2601
            int64_t delta= pkt_dts - ist->next_pts;
2602
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2603
                input_files_ts_offset[ist->file_index]-= delta;
2604
                if (verbose > 2)
2605
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2606
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2607
                if(pkt.pts != AV_NOPTS_VALUE)
2608
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2609
            }
2610
        }
2611

    
2612
        /* finish if recording time exhausted */
2613
        if (recording_time != INT64_MAX &&
2614
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2615
            ist->is_past_recording_time = 1;
2616
            goto discard_packet;
2617
        }
2618

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

    
2622
            if (verbose >= 0)
2623
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2624
                        ist->file_index, ist->index);
2625
            if (exit_on_error)
2626
                ffmpeg_exit(1);
2627
            av_free_packet(&pkt);
2628
            goto redo;
2629
        }
2630

    
2631
    discard_packet:
2632
        av_free_packet(&pkt);
2633

    
2634
        /* dump report by using the output first video and audio streams */
2635
        print_report(output_files, ost_table, nb_ostreams, 0);
2636
    }
2637

    
2638
    /* at the end of stream, we must flush the decoder buffers */
2639
    for(i=0;i<nb_istreams;i++) {
2640
        ist = ist_table[i];
2641
        if (ist->decoding_needed) {
2642
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2643
        }
2644
    }
2645

    
2646
    term_exit();
2647

    
2648
    /* write the trailer if needed and close file */
2649
    for(i=0;i<nb_output_files;i++) {
2650
        os = output_files[i];
2651
        av_write_trailer(os);
2652
    }
2653

    
2654
    /* dump report by using the first video and audio streams */
2655
    print_report(output_files, ost_table, nb_ostreams, 1);
2656

    
2657
    /* close each encoder */
2658
    for(i=0;i<nb_ostreams;i++) {
2659
        ost = ost_table[i];
2660
        if (ost->encoding_needed) {
2661
            av_freep(&ost->st->codec->stats_in);
2662
            avcodec_close(ost->st->codec);
2663
        }
2664
    }
2665

    
2666
    /* close each decoder */
2667
    for(i=0;i<nb_istreams;i++) {
2668
        ist = ist_table[i];
2669
        if (ist->decoding_needed) {
2670
            avcodec_close(ist->st->codec);
2671
        }
2672
    }
2673
#if CONFIG_AVFILTER
2674
    if (graph) {
2675
        avfilter_graph_free(graph);
2676
        av_freep(&graph);
2677
    }
2678
#endif
2679

    
2680
    /* finished ! */
2681
    ret = 0;
2682

    
2683
 fail:
2684
    av_freep(&bit_buffer);
2685
    av_free(file_table);
2686

    
2687
    if (ist_table) {
2688
        for(i=0;i<nb_istreams;i++) {
2689
            ist = ist_table[i];
2690
            av_free(ist);
2691
        }
2692
        av_free(ist_table);
2693
    }
2694
    if (ost_table) {
2695
        for(i=0;i<nb_ostreams;i++) {
2696
            ost = ost_table[i];
2697
            if (ost) {
2698
                if (ost->st->stream_copy)
2699
                    av_freep(&ost->st->codec->extradata);
2700
                if (ost->logfile) {
2701
                    fclose(ost->logfile);
2702
                    ost->logfile = NULL;
2703
                }
2704
                av_fifo_free(ost->fifo); /* works even if fifo is not
2705
                                             initialized but set to zero */
2706
                av_freep(&ost->st->codec->subtitle_header);
2707
                av_free(ost->pict_tmp.data[0]);
2708
                av_free(ost->forced_kf_pts);
2709
                if (ost->video_resample)
2710
                    sws_freeContext(ost->img_resample_ctx);
2711
                if (ost->resample)
2712
                    audio_resample_close(ost->resample);
2713
                if (ost->reformat_ctx)
2714
                    av_audio_convert_free(ost->reformat_ctx);
2715
                av_free(ost);
2716
            }
2717
        }
2718
        av_free(ost_table);
2719
    }
2720
    return ret;
2721
}
2722

    
2723
static void opt_format(const char *arg)
2724
{
2725
    last_asked_format = arg;
2726
}
2727

    
2728
static void opt_video_rc_override_string(const char *arg)
2729
{
2730
    video_rc_override_string = arg;
2731
}
2732

    
2733
static int opt_me_threshold(const char *opt, const char *arg)
2734
{
2735
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2736
    return 0;
2737
}
2738

    
2739
static int opt_verbose(const char *opt, const char *arg)
2740
{
2741
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2742
    return 0;
2743
}
2744

    
2745
static int opt_frame_rate(const char *opt, const char *arg)
2746
{
2747
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2748
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2749
        ffmpeg_exit(1);
2750
    }
2751
    return 0;
2752
}
2753

    
2754
static int opt_bitrate(const char *opt, const char *arg)
2755
{
2756
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2757

    
2758
    opt_default(opt, arg);
2759

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

    
2763
    return 0;
2764
}
2765

    
2766
static int opt_frame_crop(const char *opt, const char *arg)
2767
{
2768
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2769
    return AVERROR(EINVAL);
2770
}
2771

    
2772
static void opt_frame_size(const char *arg)
2773
{
2774
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2775
        fprintf(stderr, "Incorrect frame size\n");
2776
        ffmpeg_exit(1);
2777
    }
2778
}
2779

    
2780
static int opt_pad(const char *opt, const char *arg) {
2781
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2782
    return -1;
2783
}
2784

    
2785
static void opt_frame_pix_fmt(const char *arg)
2786
{
2787
    if (strcmp(arg, "list")) {
2788
        frame_pix_fmt = av_get_pix_fmt(arg);
2789
        if (frame_pix_fmt == PIX_FMT_NONE) {
2790
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2791
            ffmpeg_exit(1);
2792
        }
2793
    } else {
2794
        show_pix_fmts();
2795
        ffmpeg_exit(0);
2796
    }
2797
}
2798

    
2799
static void opt_frame_aspect_ratio(const char *arg)
2800
{
2801
    int x = 0, y = 0;
2802
    double ar = 0;
2803
    const char *p;
2804
    char *end;
2805

    
2806
    p = strchr(arg, ':');
2807
    if (p) {
2808
        x = strtol(arg, &end, 10);
2809
        if (end == p)
2810
            y = strtol(end+1, &end, 10);
2811
        if (x > 0 && y > 0)
2812
            ar = (double)x / (double)y;
2813
    } else
2814
        ar = strtod(arg, NULL);
2815

    
2816
    if (!ar) {
2817
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2818
        ffmpeg_exit(1);
2819
    }
2820
    frame_aspect_ratio = ar;
2821
}
2822

    
2823
static int opt_metadata(const char *opt, const char *arg)
2824
{
2825
    char *mid= strchr(arg, '=');
2826

    
2827
    if(!mid){
2828
        fprintf(stderr, "Missing =\n");
2829
        ffmpeg_exit(1);
2830
    }
2831
    *mid++= 0;
2832

    
2833
    av_metadata_set2(&metadata, arg, mid, 0);
2834

    
2835
    return 0;
2836
}
2837

    
2838
static void opt_qscale(const char *arg)
2839
{
2840
    video_qscale = atof(arg);
2841
    if (video_qscale <= 0 ||
2842
        video_qscale > 255) {
2843
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2844
        ffmpeg_exit(1);
2845
    }
2846
}
2847

    
2848
static void opt_top_field_first(const char *arg)
2849
{
2850
    top_field_first= atoi(arg);
2851
}
2852

    
2853
static int opt_thread_count(const char *opt, const char *arg)
2854
{
2855
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2856
#if !HAVE_THREADS
2857
    if (verbose >= 0)
2858
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2859
#endif
2860
    return 0;
2861
}
2862

    
2863
static void opt_audio_sample_fmt(const char *arg)
2864
{
2865
    if (strcmp(arg, "list"))
2866
        audio_sample_fmt = av_get_sample_fmt(arg);
2867
    else {
2868
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2869
        ffmpeg_exit(0);
2870
    }
2871
}
2872

    
2873
static int opt_audio_rate(const char *opt, const char *arg)
2874
{
2875
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2876
    return 0;
2877
}
2878

    
2879
static int opt_audio_channels(const char *opt, const char *arg)
2880
{
2881
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2882
    return 0;
2883
}
2884

    
2885
static void opt_video_channel(const char *arg)
2886
{
2887
    video_channel = strtol(arg, NULL, 0);
2888
}
2889

    
2890
static void opt_video_standard(const char *arg)
2891
{
2892
    video_standard = av_strdup(arg);
2893
}
2894

    
2895
static void opt_codec(int *pstream_copy, char **pcodec_name,
2896
                      int codec_type, const char *arg)
2897
{
2898
    av_freep(pcodec_name);
2899
    if (!strcmp(arg, "copy")) {
2900
        *pstream_copy = 1;
2901
    } else {
2902
        *pcodec_name = av_strdup(arg);
2903
    }
2904
}
2905

    
2906
static void opt_audio_codec(const char *arg)
2907
{
2908
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2909
}
2910

    
2911
static void opt_video_codec(const char *arg)
2912
{
2913
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2914
}
2915

    
2916
static void opt_subtitle_codec(const char *arg)
2917
{
2918
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2919
}
2920

    
2921
static int opt_codec_tag(const char *opt, const char *arg)
2922
{
2923
    char *tail;
2924
    uint32_t *codec_tag;
2925

    
2926
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2927
                !strcmp(opt, "vtag") ? &video_codec_tag :
2928
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2929
    if (!codec_tag)
2930
        return -1;
2931

    
2932
    *codec_tag = strtol(arg, &tail, 0);
2933
    if (!tail || *tail)
2934
        *codec_tag = AV_RL32(arg);
2935

    
2936
    return 0;
2937
}
2938

    
2939
static void opt_map(const char *arg)
2940
{
2941
    AVStreamMap *m;
2942
    char *p;
2943

    
2944
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2945
    m = &stream_maps[nb_stream_maps-1];
2946

    
2947
    m->file_index = strtol(arg, &p, 0);
2948
    if (*p)
2949
        p++;
2950

    
2951
    m->stream_index = strtol(p, &p, 0);
2952
    if (*p) {
2953
        p++;
2954
        m->sync_file_index = strtol(p, &p, 0);
2955
        if (*p)
2956
            p++;
2957
        m->sync_stream_index = strtol(p, &p, 0);
2958
    } else {
2959
        m->sync_file_index = m->file_index;
2960
        m->sync_stream_index = m->stream_index;
2961
    }
2962
}
2963

    
2964
static void parse_meta_type(const char *arg, char *type, int *index, char **endptr)
2965
{
2966
    *endptr = arg;
2967
    if (*arg == ',') {
2968
        *type = *(++arg);
2969
        switch (*arg) {
2970
        case 'g':
2971
            break;
2972
        case 's':
2973
        case 'c':
2974
        case 'p':
2975
            *index = strtol(++arg, endptr, 0);
2976
            break;
2977
        default:
2978
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2979
            ffmpeg_exit(1);
2980
        }
2981
    } else
2982
        *type = 'g';
2983
}
2984

    
2985
static void opt_map_meta_data(const char *arg)
2986
{
2987
    AVMetaDataMap *m, *m1;
2988
    char *p;
2989

    
2990
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2991
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2992

    
2993
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
2994
    m->file = strtol(arg, &p, 0);
2995
    parse_meta_type(p, &m->type, &m->index, &p);
2996
    if (*p)
2997
        p++;
2998

    
2999
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3000
    m1->file = strtol(p, &p, 0);
3001
    parse_meta_type(p, &m1->type, &m1->index, &p);
3002

    
3003
    if (m->type == 'g' || m1->type == 'g')
3004
        metadata_global_autocopy = 0;
3005
    if (m->type == 's' || m1->type == 's')
3006
        metadata_streams_autocopy = 0;
3007
    if (m->type == 'c' || m1->type == 'c')
3008
        metadata_chapters_autocopy = 0;
3009
}
3010

    
3011
static void opt_map_chapters(const char *arg)
3012
{
3013
    AVChapterMap *c;
3014
    char *p;
3015

    
3016
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3017
                              nb_chapter_maps + 1);
3018
    c = &chapter_maps[nb_chapter_maps - 1];
3019
    c->out_file = strtol(arg, &p, 0);
3020
    if (*p)
3021
        p++;
3022

    
3023
    c->in_file = strtol(p, &p, 0);
3024
}
3025

    
3026
static void opt_input_ts_scale(const char *arg)
3027
{
3028
    unsigned int stream;
3029
    double scale;
3030
    char *p;
3031

    
3032
    stream = strtol(arg, &p, 0);
3033
    if (*p)
3034
        p++;
3035
    scale= strtod(p, &p);
3036

    
3037
    if(stream >= MAX_STREAMS)
3038
        ffmpeg_exit(1);
3039

    
3040
    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);
3041
    input_files_ts_scale[nb_input_files][stream]= scale;
3042
}
3043

    
3044
static int opt_recording_time(const char *opt, const char *arg)
3045
{
3046
    recording_time = parse_time_or_die(opt, arg, 1);
3047
    return 0;
3048
}
3049

    
3050
static int opt_start_time(const char *opt, const char *arg)
3051
{
3052
    start_time = parse_time_or_die(opt, arg, 1);
3053
    return 0;
3054
}
3055

    
3056
static int opt_recording_timestamp(const char *opt, const char *arg)
3057
{
3058
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3059
    return 0;
3060
}
3061

    
3062
static int opt_input_ts_offset(const char *opt, const char *arg)
3063
{
3064
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3065
    return 0;
3066
}
3067

    
3068
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3069
{
3070
    const char *codec_string = encoder ? "encoder" : "decoder";
3071
    AVCodec *codec;
3072

    
3073
    if(!name)
3074
        return CODEC_ID_NONE;
3075
    codec = encoder ?
3076
        avcodec_find_encoder_by_name(name) :
3077
        avcodec_find_decoder_by_name(name);
3078
    if(!codec) {
3079
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3080
        ffmpeg_exit(1);
3081
    }
3082
    if(codec->type != type) {
3083
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3084
        ffmpeg_exit(1);
3085
    }
3086
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3087
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3088
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3089
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3090
                codec_string, codec->name);
3091
        codec = encoder ?
3092
            avcodec_find_encoder(codec->id) :
3093
            avcodec_find_decoder(codec->id);
3094
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3095
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3096
                    codec_string, codec->name);
3097
        ffmpeg_exit(1);
3098
    }
3099
    return codec->id;
3100
}
3101

    
3102
static void opt_input_file(const char *filename)
3103
{
3104
    AVFormatContext *ic;
3105
    AVFormatParameters params, *ap = &params;
3106
    AVInputFormat *file_iformat = NULL;
3107
    int err, i, ret, rfps, rfps_base;
3108
    int64_t timestamp;
3109

    
3110
    if (last_asked_format) {
3111
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3112
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3113
            ffmpeg_exit(1);
3114
        }
3115
        last_asked_format = NULL;
3116
    }
3117

    
3118
    if (!strcmp(filename, "-"))
3119
        filename = "pipe:";
3120

    
3121
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3122
                    !strcmp(filename, "/dev/stdin");
3123

    
3124
    /* get default parameters from command line */
3125
    ic = avformat_alloc_context();
3126
    if (!ic) {
3127
        print_error(filename, AVERROR(ENOMEM));
3128
        ffmpeg_exit(1);
3129
    }
3130

    
3131
    memset(ap, 0, sizeof(*ap));
3132
    ap->prealloced_context = 1;
3133
    ap->sample_rate = audio_sample_rate;
3134
    ap->channels = audio_channels;
3135
    ap->time_base.den = frame_rate.num;
3136
    ap->time_base.num = frame_rate.den;
3137
    ap->width = frame_width;
3138
    ap->height = frame_height;
3139
    ap->pix_fmt = frame_pix_fmt;
3140
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3141
    ap->channel = video_channel;
3142
    ap->standard = video_standard;
3143

    
3144
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3145

    
3146
    ic->video_codec_id   =
3147
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3148
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3149
    ic->audio_codec_id   =
3150
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3151
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3152
    ic->subtitle_codec_id=
3153
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3154
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3155
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3156

    
3157
    /* open the input file with generic libav function */
3158
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3159
    if (err < 0) {
3160
        print_error(filename, err);
3161
        ffmpeg_exit(1);
3162
    }
3163
    if(opt_programid) {
3164
        int i, j;
3165
        int found=0;
3166
        for(i=0; i<ic->nb_streams; i++){
3167
            ic->streams[i]->discard= AVDISCARD_ALL;
3168
        }
3169
        for(i=0; i<ic->nb_programs; i++){
3170
            AVProgram *p= ic->programs[i];
3171
            if(p->id != opt_programid){
3172
                p->discard = AVDISCARD_ALL;
3173
            }else{
3174
                found=1;
3175
                for(j=0; j<p->nb_stream_indexes; j++){
3176
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3177
                }
3178
            }
3179
        }
3180
        if(!found){
3181
            fprintf(stderr, "Specified program id not found\n");
3182
            ffmpeg_exit(1);
3183
        }
3184
        opt_programid=0;
3185
    }
3186

    
3187
    ic->loop_input = loop_input;
3188

    
3189
    /* If not enough info to get the stream parameters, we decode the
3190
       first frames to get it. (used in mpeg case for example) */
3191
    ret = av_find_stream_info(ic);
3192
    if (ret < 0 && verbose >= 0) {
3193
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3194
        av_close_input_file(ic);
3195
        ffmpeg_exit(1);
3196
    }
3197

    
3198
    timestamp = start_time;
3199
    /* add the stream start time */
3200
    if (ic->start_time != AV_NOPTS_VALUE)
3201
        timestamp += ic->start_time;
3202

    
3203
    /* if seeking requested, we execute it */
3204
    if (start_time != 0) {
3205
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3206
        if (ret < 0) {
3207
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3208
                    filename, (double)timestamp / AV_TIME_BASE);
3209
        }
3210
        /* reset seek info */
3211
        start_time = 0;
3212
    }
3213

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

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

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

    
3264
                    (float)rfps / rfps_base, rfps, rfps_base);
3265
            }
3266
            /* update the current frame rate to match the stream frame rate */
3267
            frame_rate.num = rfps;
3268
            frame_rate.den = rfps_base;
3269

    
3270
            if(video_disable)
3271
                st->discard= AVDISCARD_ALL;
3272
            else if(video_discard)
3273
                st->discard= video_discard;
3274
            break;
3275
        case AVMEDIA_TYPE_DATA:
3276
            break;
3277
        case AVMEDIA_TYPE_SUBTITLE:
3278
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3279
            if(subtitle_disable)
3280
                st->discard = AVDISCARD_ALL;
3281
            break;
3282
        case AVMEDIA_TYPE_ATTACHMENT:
3283
        case AVMEDIA_TYPE_UNKNOWN:
3284
            break;
3285
        default:
3286
            abort();
3287
        }
3288
    }
3289

    
3290
    input_files[nb_input_files] = ic;
3291
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3292
    /* dump the file content */
3293
    if (verbose >= 0)
3294
        dump_format(ic, nb_input_files, filename, 0);
3295

    
3296
    nb_input_files++;
3297

    
3298
    video_channel = 0;
3299

    
3300
    av_freep(&video_codec_name);
3301
    av_freep(&audio_codec_name);
3302
    av_freep(&subtitle_codec_name);
3303
}
3304

    
3305
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3306
                                         int *has_subtitle_ptr)
3307
{
3308
    int has_video, has_audio, has_subtitle, i, j;
3309
    AVFormatContext *ic;
3310

    
3311
    has_video = 0;
3312
    has_audio = 0;
3313
    has_subtitle = 0;
3314
    for(j=0;j<nb_input_files;j++) {
3315
        ic = input_files[j];
3316
        for(i=0;i<ic->nb_streams;i++) {
3317
            AVCodecContext *enc = ic->streams[i]->codec;
3318
            switch(enc->codec_type) {
3319
            case AVMEDIA_TYPE_AUDIO:
3320
                has_audio = 1;
3321
                break;
3322
            case AVMEDIA_TYPE_VIDEO:
3323
                has_video = 1;
3324
                break;
3325
            case AVMEDIA_TYPE_SUBTITLE:
3326
                has_subtitle = 1;
3327
                break;
3328
            case AVMEDIA_TYPE_DATA:
3329
            case AVMEDIA_TYPE_ATTACHMENT:
3330
            case AVMEDIA_TYPE_UNKNOWN:
3331
                break;
3332
            default:
3333
                abort();
3334
            }
3335
        }
3336
    }
3337
    *has_video_ptr = has_video;
3338
    *has_audio_ptr = has_audio;
3339
    *has_subtitle_ptr = has_subtitle;
3340
}
3341

    
3342
static void new_video_stream(AVFormatContext *oc, int file_idx)
3343
{
3344
    AVStream *st;
3345
    AVOutputStream *ost;
3346
    AVCodecContext *video_enc;
3347
    enum CodecID codec_id;
3348
    AVCodec *codec= NULL;
3349

    
3350
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3351
    if (!st) {
3352
        fprintf(stderr, "Could not alloc stream\n");
3353
        ffmpeg_exit(1);
3354
    }
3355
    ost = new_output_stream(oc, file_idx);
3356

    
3357
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3358
    if(!video_stream_copy){
3359
        if (video_codec_name) {
3360
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3361
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3362
            codec = avcodec_find_encoder_by_name(video_codec_name);
3363
            output_codecs[nb_output_codecs-1] = codec;
3364
        } else {
3365
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3366
            codec = avcodec_find_encoder(codec_id);
3367
        }
3368
    }
3369

    
3370
    avcodec_get_context_defaults3(st->codec, codec);
3371
    ost->bitstream_filters = video_bitstream_filters;
3372
    video_bitstream_filters= NULL;
3373

    
3374
    avcodec_thread_init(st->codec, thread_count);
3375

    
3376
    video_enc = st->codec;
3377

    
3378
    if(video_codec_tag)
3379
        video_enc->codec_tag= video_codec_tag;
3380

    
3381
    if(   (video_global_header&1)
3382
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3383
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3384
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3385
    }
3386
    if(video_global_header&2){
3387
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3388
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3389
    }
3390

    
3391
    if (video_stream_copy) {
3392
        st->stream_copy = 1;
3393
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3394
        video_enc->sample_aspect_ratio =
3395
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3396
    } else {
3397
        const char *p;
3398
        int i;
3399
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3400

    
3401
        video_enc->codec_id = codec_id;
3402
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3403

    
3404
        if (codec && codec->supported_framerates && !force_fps)
3405
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3406
        video_enc->time_base.den = fps.num;
3407
        video_enc->time_base.num = fps.den;
3408

    
3409
        video_enc->width = frame_width;
3410
        video_enc->height = frame_height;
3411
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3412
        video_enc->pix_fmt = frame_pix_fmt;
3413
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3414

    
3415
        choose_pixel_fmt(st, codec);
3416

    
3417
        if (intra_only)
3418
            video_enc->gop_size = 0;
3419
        if (video_qscale || same_quality) {
3420
            video_enc->flags |= CODEC_FLAG_QSCALE;
3421
            video_enc->global_quality=
3422
                st->quality = FF_QP2LAMBDA * video_qscale;
3423
        }
3424

    
3425
        if(intra_matrix)
3426
            video_enc->intra_matrix = intra_matrix;
3427
        if(inter_matrix)
3428
            video_enc->inter_matrix = inter_matrix;
3429

    
3430
        p= video_rc_override_string;
3431
        for(i=0; p; i++){
3432
            int start, end, q;
3433
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3434
            if(e!=3){
3435
                fprintf(stderr, "error parsing rc_override\n");
3436
                ffmpeg_exit(1);
3437
            }
3438
            video_enc->rc_override=
3439
                av_realloc(video_enc->rc_override,
3440
                           sizeof(RcOverride)*(i+1));
3441
            video_enc->rc_override[i].start_frame= start;
3442
            video_enc->rc_override[i].end_frame  = end;
3443
            if(q>0){
3444
                video_enc->rc_override[i].qscale= q;
3445
                video_enc->rc_override[i].quality_factor= 1.0;
3446
            }
3447
            else{
3448
                video_enc->rc_override[i].qscale= 0;
3449
                video_enc->rc_override[i].quality_factor= -q/100.0;
3450
            }
3451
            p= strchr(p, '/');
3452
            if(p) p++;
3453
        }
3454
        video_enc->rc_override_count=i;
3455
        if (!video_enc->rc_initial_buffer_occupancy)
3456
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3457
        video_enc->me_threshold= me_threshold;
3458
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3459

    
3460
        if (do_psnr)
3461
            video_enc->flags|= CODEC_FLAG_PSNR;
3462

    
3463
        /* two pass mode */
3464
        if (do_pass) {
3465
            if (do_pass == 1) {
3466
                video_enc->flags |= CODEC_FLAG_PASS1;
3467
            } else {
3468
                video_enc->flags |= CODEC_FLAG_PASS2;
3469
            }
3470
        }
3471

    
3472
        if (forced_key_frames)
3473
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3474
    }
3475
    if (video_language) {
3476
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3477
        av_freep(&video_language);
3478
    }
3479

    
3480
    /* reset some key parameters */
3481
    video_disable = 0;
3482
    av_freep(&video_codec_name);
3483
    av_freep(&forced_key_frames);
3484
    video_stream_copy = 0;
3485
    frame_pix_fmt = PIX_FMT_NONE;
3486
}
3487

    
3488
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3489
{
3490
    AVStream *st;
3491
    AVOutputStream *ost;
3492
    AVCodec *codec= NULL;
3493
    AVCodecContext *audio_enc;
3494
    enum CodecID codec_id;
3495

    
3496
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3497
    if (!st) {
3498
        fprintf(stderr, "Could not alloc stream\n");
3499
        ffmpeg_exit(1);
3500
    }
3501
    ost = new_output_stream(oc, file_idx);
3502

    
3503
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3504
    if(!audio_stream_copy){
3505
        if (audio_codec_name) {
3506
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3507
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3508
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3509
            output_codecs[nb_output_codecs-1] = codec;
3510
        } else {
3511
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3512
            codec = avcodec_find_encoder(codec_id);
3513
        }
3514
    }
3515

    
3516
    avcodec_get_context_defaults3(st->codec, codec);
3517

    
3518
    ost->bitstream_filters = audio_bitstream_filters;
3519
    audio_bitstream_filters= NULL;
3520

    
3521
    avcodec_thread_init(st->codec, thread_count);
3522

    
3523
    audio_enc = st->codec;
3524
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3525

    
3526
    if(audio_codec_tag)
3527
        audio_enc->codec_tag= audio_codec_tag;
3528

    
3529
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3530
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3531
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3532
    }
3533
    if (audio_stream_copy) {
3534
        st->stream_copy = 1;
3535
        audio_enc->channels = audio_channels;
3536
        audio_enc->sample_rate = audio_sample_rate;
3537
    } else {
3538
        audio_enc->codec_id = codec_id;
3539
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3540

    
3541
        if (audio_qscale > QSCALE_NONE) {
3542
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3543
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3544
        }
3545
        audio_enc->channels = audio_channels;
3546
        audio_enc->sample_fmt = audio_sample_fmt;
3547
        audio_enc->sample_rate = audio_sample_rate;
3548
        audio_enc->channel_layout = channel_layout;
3549
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3550
            audio_enc->channel_layout = 0;
3551
        choose_sample_fmt(st, codec);
3552
        choose_sample_rate(st, codec);
3553
    }
3554
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3555
    if (audio_language) {
3556
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3557
        av_freep(&audio_language);
3558
    }
3559

    
3560
    /* reset some key parameters */
3561
    audio_disable = 0;
3562
    av_freep(&audio_codec_name);
3563
    audio_stream_copy = 0;
3564
}
3565

    
3566
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3567
{
3568
    AVStream *st;
3569
    AVOutputStream *ost;
3570
    AVCodec *codec=NULL;
3571
    AVCodecContext *subtitle_enc;
3572

    
3573
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3574
    if (!st) {
3575
        fprintf(stderr, "Could not alloc stream\n");
3576
        ffmpeg_exit(1);
3577
    }
3578
    ost = new_output_stream(oc, file_idx);
3579
    subtitle_enc = st->codec;
3580
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3581
    if(!subtitle_stream_copy){
3582
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3583
                                                   avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3584
        codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3585
    }
3586
    avcodec_get_context_defaults3(st->codec, codec);
3587

    
3588
    ost->bitstream_filters = subtitle_bitstream_filters;
3589
    subtitle_bitstream_filters= NULL;
3590

    
3591
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3592

    
3593
    if(subtitle_codec_tag)
3594
        subtitle_enc->codec_tag= subtitle_codec_tag;
3595

    
3596
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3597
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3598
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3599
    }
3600
    if (subtitle_stream_copy) {
3601
        st->stream_copy = 1;
3602
    } else {
3603
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3604
    }
3605

    
3606
    if (subtitle_language) {
3607
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3608
        av_freep(&subtitle_language);
3609
    }
3610

    
3611
    subtitle_disable = 0;
3612
    av_freep(&subtitle_codec_name);
3613
    subtitle_stream_copy = 0;
3614
}
3615

    
3616
static int opt_new_stream(const char *opt, const char *arg)
3617
{
3618
    AVFormatContext *oc;
3619
    int file_idx = nb_output_files - 1;
3620
    if (nb_output_files <= 0) {
3621
        fprintf(stderr, "At least one output file must be specified\n");
3622
        ffmpeg_exit(1);
3623
    }
3624
    oc = output_files[file_idx];
3625

    
3626
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3627
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3628
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3629
    else av_assert0(0);
3630
    return 0;
3631
}
3632

    
3633
/* arg format is "output-stream-index:streamid-value". */
3634
static int opt_streamid(const char *opt, const char *arg)
3635
{
3636
    int idx;
3637
    char *p;
3638
    char idx_str[16];
3639

    
3640
    strncpy(idx_str, arg, sizeof(idx_str));
3641
    idx_str[sizeof(idx_str)-1] = '\0';
3642
    p = strchr(idx_str, ':');
3643
    if (!p) {
3644
        fprintf(stderr,
3645
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3646
                arg, opt);
3647
        ffmpeg_exit(1);
3648
    }
3649
    *p++ = '\0';
3650
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3651
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3652
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3653
    return 0;
3654
}
3655

    
3656
static void opt_output_file(const char *filename)
3657
{
3658
    AVFormatContext *oc;
3659
    int err, use_video, use_audio, use_subtitle;
3660
    int input_has_video, input_has_audio, input_has_subtitle;
3661
    AVFormatParameters params, *ap = &params;
3662
    AVOutputFormat *file_oformat;
3663
    AVMetadataTag *tag = NULL;
3664

    
3665
    if (!strcmp(filename, "-"))
3666
        filename = "pipe:";
3667

    
3668
    oc = avformat_alloc_context();
3669
    if (!oc) {
3670
        print_error(filename, AVERROR(ENOMEM));
3671
        ffmpeg_exit(1);
3672
    }
3673

    
3674
    if (last_asked_format) {
3675
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3676
        if (!file_oformat) {
3677
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3678
            ffmpeg_exit(1);
3679
        }
3680
        last_asked_format = NULL;
3681
    } else {
3682
        file_oformat = av_guess_format(NULL, filename, NULL);
3683
        if (!file_oformat) {
3684
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3685
                    filename);
3686
            ffmpeg_exit(1);
3687
        }
3688
    }
3689

    
3690
    oc->oformat = file_oformat;
3691
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3692

    
3693
    if (!strcmp(file_oformat->name, "ffm") &&
3694
        av_strstart(filename, "http:", NULL)) {
3695
        /* special case for files sent to ffserver: we get the stream
3696
           parameters from ffserver */
3697
        int err = read_ffserver_streams(oc, filename);
3698
        if (err < 0) {
3699
            print_error(filename, err);
3700
            ffmpeg_exit(1);
3701
        }
3702
    } else {
3703
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3704
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3705
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3706

    
3707
        /* disable if no corresponding type found and at least one
3708
           input file */
3709
        if (nb_input_files > 0) {
3710
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3711
                                         &input_has_subtitle);
3712
            if (!input_has_video)
3713
                use_video = 0;
3714
            if (!input_has_audio)
3715
                use_audio = 0;
3716
            if (!input_has_subtitle)
3717
                use_subtitle = 0;
3718
        }
3719

    
3720
        /* manual disable */
3721
        if (audio_disable)    use_audio    = 0;
3722
        if (video_disable)    use_video    = 0;
3723
        if (subtitle_disable) use_subtitle = 0;
3724

    
3725
        if (use_video)    new_video_stream(oc, nb_output_files);
3726
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3727
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3728

    
3729
        oc->timestamp = recording_timestamp;
3730

    
3731
        while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
3732
            av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
3733
        av_metadata_free(&metadata);
3734
    }
3735

    
3736
    output_files[nb_output_files++] = oc;
3737

    
3738
    /* check filename in case of an image number is expected */
3739
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3740
        if (!av_filename_number_test(oc->filename)) {
3741
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3742
            ffmpeg_exit(1);
3743
        }
3744
    }
3745

    
3746
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3747
        /* test if it already exists to avoid loosing precious files */
3748
        if (!file_overwrite &&
3749
            (strchr(filename, ':') == NULL ||
3750
             filename[1] == ':' ||
3751
             av_strstart(filename, "file:", NULL))) {
3752
            if (url_exist(filename)) {
3753
                if (!using_stdin) {
3754
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3755
                    fflush(stderr);
3756
                    if (!read_yesno()) {
3757
                        fprintf(stderr, "Not overwriting - exiting\n");
3758
                        ffmpeg_exit(1);
3759
                    }
3760
                }
3761
                else {
3762
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3763
                    ffmpeg_exit(1);
3764
                }
3765
            }
3766
        }
3767

    
3768
        /* open the file */
3769
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3770
            print_error(filename, err);
3771
            ffmpeg_exit(1);
3772
        }
3773
    }
3774

    
3775
    memset(ap, 0, sizeof(*ap));
3776
    if (av_set_parameters(oc, ap) < 0) {
3777
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3778
                oc->filename);
3779
        ffmpeg_exit(1);
3780
    }
3781

    
3782
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3783
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3784
    oc->loop_output = loop_output;
3785
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3786

    
3787
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3788

    
3789
    nb_streamid_map = 0;
3790
    av_freep(&forced_key_frames);
3791
}
3792

    
3793
/* same option as mencoder */
3794
static void opt_pass(const char *pass_str)
3795
{
3796
    int pass;
3797
    pass = atoi(pass_str);
3798
    if (pass != 1 && pass != 2) {
3799
        fprintf(stderr, "pass number can be only 1 or 2\n");
3800
        ffmpeg_exit(1);
3801
    }
3802
    do_pass = pass;
3803
}
3804

    
3805
static int64_t getutime(void)
3806
{
3807
#if HAVE_GETRUSAGE
3808
    struct rusage rusage;
3809

    
3810
    getrusage(RUSAGE_SELF, &rusage);
3811
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3812
#elif HAVE_GETPROCESSTIMES
3813
    HANDLE proc;
3814
    FILETIME c, e, k, u;
3815
    proc = GetCurrentProcess();
3816
    GetProcessTimes(proc, &c, &e, &k, &u);
3817
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3818
#else
3819
    return av_gettime();
3820
#endif
3821
}
3822

    
3823
static int64_t getmaxrss(void)
3824
{
3825
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3826
    struct rusage rusage;
3827
    getrusage(RUSAGE_SELF, &rusage);
3828
    return (int64_t)rusage.ru_maxrss * 1024;
3829
#elif HAVE_GETPROCESSMEMORYINFO
3830
    HANDLE proc;
3831
    PROCESS_MEMORY_COUNTERS memcounters;
3832
    proc = GetCurrentProcess();
3833
    memcounters.cb = sizeof(memcounters);
3834
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3835
    return memcounters.PeakPagefileUsage;
3836
#else
3837
    return 0;
3838
#endif
3839
}
3840

    
3841
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3842
{
3843
    int i;
3844
    const char *p = str;
3845
    for(i = 0;; i++) {
3846
        dest[i] = atoi(p);
3847
        if(i == 63)
3848
            break;
3849
        p = strchr(p, ',');
3850
        if(!p) {
3851
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3852
            ffmpeg_exit(1);
3853
        }
3854
        p++;
3855
    }
3856
}
3857

    
3858
static void opt_inter_matrix(const char *arg)
3859
{
3860
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3861
    parse_matrix_coeffs(inter_matrix, arg);
3862
}
3863

    
3864
static void opt_intra_matrix(const char *arg)
3865
{
3866
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3867
    parse_matrix_coeffs(intra_matrix, arg);
3868
}
3869

    
3870
static void show_usage(void)
3871
{
3872
    printf("Hyper fast Audio and Video encoder\n");
3873
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3874
    printf("\n");
3875
}
3876

    
3877
static void show_help(void)
3878
{
3879
    av_log_set_callback(log_callback_help);
3880
    show_usage();
3881
    show_help_options(options, "Main options:\n",
3882
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3883
    show_help_options(options, "\nAdvanced options:\n",
3884
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3885
                      OPT_EXPERT);
3886
    show_help_options(options, "\nVideo options:\n",
3887
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3888
                      OPT_VIDEO);
3889
    show_help_options(options, "\nAdvanced Video options:\n",
3890
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3891
                      OPT_VIDEO | OPT_EXPERT);
3892
    show_help_options(options, "\nAudio options:\n",
3893
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3894
                      OPT_AUDIO);
3895
    show_help_options(options, "\nAdvanced Audio options:\n",
3896
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3897
                      OPT_AUDIO | OPT_EXPERT);
3898
    show_help_options(options, "\nSubtitle options:\n",
3899
                      OPT_SUBTITLE | OPT_GRAB,
3900
                      OPT_SUBTITLE);
3901
    show_help_options(options, "\nAudio/Video grab options:\n",
3902
                      OPT_GRAB,
3903
                      OPT_GRAB);
3904
    printf("\n");
3905
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3906
    printf("\n");
3907
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3908
    printf("\n");
3909
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3910
}
3911

    
3912
static void opt_target(const char *arg)
3913
{
3914
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3915
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3916

    
3917
    if(!strncmp(arg, "pal-", 4)) {
3918
        norm = PAL;
3919
        arg += 4;
3920
    } else if(!strncmp(arg, "ntsc-", 5)) {
3921
        norm = NTSC;
3922
        arg += 5;
3923
    } else if(!strncmp(arg, "film-", 5)) {
3924
        norm = FILM;
3925
        arg += 5;
3926
    } else {
3927
        int fr;
3928
        /* Calculate FR via float to avoid int overflow */
3929
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3930
        if(fr == 25000) {
3931
            norm = PAL;
3932
        } else if((fr == 29970) || (fr == 23976)) {
3933
            norm = NTSC;
3934
        } else {
3935
            /* Try to determine PAL/NTSC by peeking in the input files */
3936
            if(nb_input_files) {
3937
                int i, j;
3938
                for(j = 0; j < nb_input_files; j++) {
3939
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3940
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3941
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3942
                            continue;
3943
                        fr = c->time_base.den * 1000 / c->time_base.num;
3944
                        if(fr == 25000) {
3945
                            norm = PAL;
3946
                            break;
3947
                        } else if((fr == 29970) || (fr == 23976)) {
3948
                            norm = NTSC;
3949
                            break;
3950
                        }
3951
                    }
3952
                    if(norm != UNKNOWN)
3953
                        break;
3954
                }
3955
            }
3956
        }
3957
        if(verbose && norm != UNKNOWN)
3958
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3959
    }
3960

    
3961
    if(norm == UNKNOWN) {
3962
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3963
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3964
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3965
        ffmpeg_exit(1);
3966
    }
3967

    
3968
    if(!strcmp(arg, "vcd")) {
3969

    
3970
        opt_video_codec("mpeg1video");
3971
        opt_audio_codec("mp2");
3972
        opt_format("vcd");
3973

    
3974
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3975
        opt_frame_rate(NULL, frame_rates[norm]);
3976
        opt_default("g", norm == PAL ? "15" : "18");
3977

    
3978
        opt_default("b", "1150000");
3979
        opt_default("maxrate", "1150000");
3980
        opt_default("minrate", "1150000");
3981
        opt_default("bufsize", "327680"); // 40*1024*8;
3982

    
3983
        opt_default("ab", "224000");
3984
        audio_sample_rate = 44100;
3985
        audio_channels = 2;
3986

    
3987
        opt_default("packetsize", "2324");
3988
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3989

    
3990
        /* We have to offset the PTS, so that it is consistent with the SCR.
3991
           SCR starts at 36000, but the first two packs contain only padding
3992
           and the first pack from the other stream, respectively, may also have
3993
           been written before.
3994
           So the real data starts at SCR 36000+3*1200. */
3995
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3996
    } else if(!strcmp(arg, "svcd")) {
3997

    
3998
        opt_video_codec("mpeg2video");
3999
        opt_audio_codec("mp2");
4000
        opt_format("svcd");
4001

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

    
4006
        opt_default("b", "2040000");
4007
        opt_default("maxrate", "2516000");
4008
        opt_default("minrate", "0"); //1145000;
4009
        opt_default("bufsize", "1835008"); //224*1024*8;
4010
        opt_default("flags", "+scan_offset");
4011

    
4012

    
4013
        opt_default("ab", "224000");
4014
        audio_sample_rate = 44100;
4015

    
4016
        opt_default("packetsize", "2324");
4017

    
4018
    } else if(!strcmp(arg, "dvd")) {
4019

    
4020
        opt_video_codec("mpeg2video");
4021
        opt_audio_codec("ac3");
4022
        opt_format("dvd");
4023

    
4024
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4025
        opt_frame_rate(NULL, frame_rates[norm]);
4026
        opt_default("g", norm == PAL ? "15" : "18");
4027

    
4028
        opt_default("b", "6000000");
4029
        opt_default("maxrate", "9000000");
4030
        opt_default("minrate", "0"); //1500000;
4031
        opt_default("bufsize", "1835008"); //224*1024*8;
4032

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

    
4036
        opt_default("ab", "448000");
4037
        audio_sample_rate = 48000;
4038

    
4039
    } else if(!strncmp(arg, "dv", 2)) {
4040

    
4041
        opt_format("dv");
4042

    
4043
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4044
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4045
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4046
        opt_frame_rate(NULL, frame_rates[norm]);
4047

    
4048
        audio_sample_rate = 48000;
4049
        audio_channels = 2;
4050

    
4051
    } else {
4052
        fprintf(stderr, "Unknown target: %s\n", arg);
4053
        ffmpeg_exit(1);
4054
    }
4055
}
4056

    
4057
static void opt_vstats_file (const char *arg)
4058
{
4059
    av_free (vstats_filename);
4060
    vstats_filename=av_strdup (arg);
4061
}
4062

    
4063
static void opt_vstats (void)
4064
{
4065
    char filename[40];
4066
    time_t today2 = time(NULL);
4067
    struct tm *today = localtime(&today2);
4068

    
4069
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4070
             today->tm_sec);
4071
    opt_vstats_file(filename);
4072
}
4073

    
4074
static int opt_bsf(const char *opt, const char *arg)
4075
{
4076
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4077
    AVBitStreamFilterContext **bsfp;
4078

    
4079
    if(!bsfc){
4080
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4081
        ffmpeg_exit(1);
4082
    }
4083

    
4084
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4085
          *opt == 'a' ? &audio_bitstream_filters :
4086
                        &subtitle_bitstream_filters;
4087
    while(*bsfp)
4088
        bsfp= &(*bsfp)->next;
4089

    
4090
    *bsfp= bsfc;
4091

    
4092
    return 0;
4093
}
4094

    
4095
static int opt_preset(const char *opt, const char *arg)
4096
{
4097
    FILE *f=NULL;
4098
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4099
    char *codec_name = *opt == 'v' ? video_codec_name :
4100
                       *opt == 'a' ? audio_codec_name :
4101
                                     subtitle_codec_name;
4102

    
4103
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4104
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4105
        ffmpeg_exit(1);
4106
    }
4107

    
4108
    while(!feof(f)){
4109
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4110
        if(line[0] == '#' && !e)
4111
            continue;
4112
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4113
        if(e){
4114
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4115
            ffmpeg_exit(1);
4116
        }
4117
        if(!strcmp(tmp, "acodec")){
4118
            opt_audio_codec(tmp2);
4119
        }else if(!strcmp(tmp, "vcodec")){
4120
            opt_video_codec(tmp2);
4121
        }else if(!strcmp(tmp, "scodec")){
4122
            opt_subtitle_codec(tmp2);
4123
        }else if(opt_default(tmp, tmp2) < 0){
4124
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4125
            ffmpeg_exit(1);
4126
        }
4127
    }
4128

    
4129
    fclose(f);
4130

    
4131
    return 0;
4132
}
4133

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

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

    
4223
    /* audio options */
4224
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4225
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4226
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4227
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4228
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4229
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4230
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4231
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4232
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4233
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4234
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4235
    { "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" },
4236

    
4237
    /* subtitle options */
4238
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4239
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4240
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4241
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4242
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4243

    
4244
    /* grab options */
4245
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4246
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4247
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4248

    
4249
    /* muxer options */
4250
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4251
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4252

    
4253
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4254
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4255
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4256

    
4257
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4258
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4259
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4260
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4261

    
4262
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4263
    { NULL, },
4264
};
4265

    
4266
int main(int argc, char **argv)
4267
{
4268
    int64_t ti;
4269

    
4270
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4271

    
4272
    avcodec_register_all();
4273
#if CONFIG_AVDEVICE
4274
    avdevice_register_all();
4275
#endif
4276
#if CONFIG_AVFILTER
4277
    avfilter_register_all();
4278
#endif
4279
    av_register_all();
4280

    
4281
#if HAVE_ISATTY
4282
    if(isatty(STDIN_FILENO))
4283
        url_set_interrupt_cb(decode_interrupt_cb);
4284
#endif
4285

    
4286
    init_opts();
4287

    
4288
    show_banner();
4289

    
4290
    /* parse options */
4291
    parse_options(argc, argv, options, opt_output_file);
4292

    
4293
    if(nb_output_files <= 0 && nb_input_files == 0) {
4294
        show_usage();
4295
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4296
        ffmpeg_exit(1);
4297
    }
4298

    
4299
    /* file converter / grab */
4300
    if (nb_output_files <= 0) {
4301
        fprintf(stderr, "At least one output file must be specified\n");
4302
        ffmpeg_exit(1);
4303
    }
4304

    
4305
    if (nb_input_files == 0) {
4306
        fprintf(stderr, "At least one input file must be specified\n");
4307
        ffmpeg_exit(1);
4308
    }
4309

    
4310
    ti = getutime();
4311
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4312
                  stream_maps, nb_stream_maps) < 0)
4313
        ffmpeg_exit(1);
4314
    ti = getutime() - ti;
4315
    if (do_benchmark) {
4316
        int maxrss = getmaxrss() / 1024;
4317
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4318
    }
4319

    
4320
    return ffmpeg_exit(0);
4321
}