Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 97dd1e4a

History | View | Annotate | Download (155 KB)

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

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

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

    
49
#if CONFIG_AVFILTER
50
# include "libavfilter/avfilter.h"
51
# include "libavfilter/avfiltergraph.h"
52
# include "libavfilter/graphparser.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
static const OptionDef options[];
107

    
108
#define MAX_FILES 100
109
#if !FF_API_MAX_STREAMS
110
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
111
#endif
112

    
113
static const char *last_asked_format = NULL;
114
static AVFormatContext *input_files[MAX_FILES];
115
static int64_t input_files_ts_offset[MAX_FILES];
116
static double *input_files_ts_scale[MAX_FILES] = {NULL};
117
static AVCodec **input_codecs = NULL;
118
static int nb_input_files = 0;
119
static int nb_input_codecs = 0;
120
static int nb_input_files_ts_scale[MAX_FILES] = {0};
121

    
122
static AVFormatContext *output_files[MAX_FILES];
123
static AVCodec **output_codecs = NULL;
124
static int nb_output_files = 0;
125
static int nb_output_codecs = 0;
126

    
127
static AVStreamMap *stream_maps = NULL;
128
static int nb_stream_maps;
129

    
130
/* first item specifies output metadata, second is input */
131
static AVMetaDataMap (*meta_data_maps)[2] = NULL;
132
static int nb_meta_data_maps;
133
static int metadata_streams_autocopy  = 1;
134
static int metadata_chapters_autocopy = 1;
135

    
136
/* indexed by output file stream index */
137
static int *streamid_map = NULL;
138
static int nb_streamid_map = 0;
139

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

    
169
static int intra_only = 0;
170
static int audio_sample_rate = 44100;
171
static int64_t channel_layout = 0;
172
#define QSCALE_NONE -99999
173
static float audio_qscale = QSCALE_NONE;
174
static int audio_disable = 0;
175
static int audio_channels = 1;
176
static char  *audio_codec_name = NULL;
177
static unsigned int audio_codec_tag = 0;
178
static char *audio_language = NULL;
179

    
180
static int subtitle_disable = 0;
181
static char *subtitle_codec_name = NULL;
182
static char *subtitle_language = NULL;
183
static unsigned int subtitle_codec_tag = 0;
184

    
185
static float mux_preload= 0.5;
186
static float mux_max_delay= 0.7;
187

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

    
214
static int rate_emu = 0;
215

    
216
static int  video_channel = 0;
217
static char *video_standard;
218

    
219
static int audio_volume = 256;
220

    
221
static int exit_on_error = 0;
222
static int using_stdin = 0;
223
static int verbose = 1;
224
static int thread_count= 1;
225
static int q_pressed = 0;
226
static int64_t video_size = 0;
227
static int64_t audio_size = 0;
228
static int64_t extra_size = 0;
229
static int nb_frames_dup = 0;
230
static int nb_frames_drop = 0;
231
static int input_sync;
232
static uint64_t limit_filesize = 0;
233
static int force_fps = 0;
234
static char *forced_key_frames = NULL;
235

    
236
static float dts_delta_threshold = 10;
237

    
238
static unsigned int sws_flags = SWS_BICUBIC;
239

    
240
static int64_t timer_start;
241

    
242
static uint8_t *audio_buf;
243
static uint8_t *audio_out;
244
unsigned int allocated_audio_out_size, allocated_audio_buf_size;
245

    
246
static short *samples;
247

    
248
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
249
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
250
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
251

    
252
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
253

    
254
struct AVInputStream;
255

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

    
277
    /* full frame size of first frame */
278
    int original_height;
279
    int original_width;
280

    
281
    /* forced key frames */
282
    int64_t *forced_kf_pts;
283
    int forced_kf_count;
284
    int forced_kf_index;
285

    
286
    /* audio only */
287
    int audio_resample;
288
    ReSampleContext *resample; /* for audio resampling */
289
    int reformat_pair;
290
    AVAudioConvert *reformat_ctx;
291
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
292
    FILE *logfile;
293
} AVOutputStream;
294

    
295
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
296
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
297

    
298
typedef struct AVInputStream {
299
    int file_index;
300
    int index;
301
    AVStream *st;
302
    int discard;             /* true if stream data should be discarded */
303
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
304
    int64_t sample_index;      /* current sample */
305

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

    
323
typedef struct AVInputFile {
324
    int eof_reached;      /* true if eof reached */
325
    int ist_index;        /* index of first stream in ist_table */
326
    int buffer_size;      /* current total buffer size */
327
    int nb_streams;       /* nb streams we are aware of */
328
} AVInputFile;
329

    
330
#if HAVE_TERMIOS_H
331

    
332
/* init terminal so that we can grab keys */
333
static struct termios oldtty;
334
#endif
335

    
336
#if CONFIG_AVFILTER
337

    
338
static int configure_filters(AVInputStream *ist, AVOutputStream *ost)
339
{
340
    AVFilterContext *last_filter, *filter;
341
    /** filter graph containing all filters including input & output */
342
    AVCodecContext *codec = ost->st->codec;
343
    AVCodecContext *icodec = ist->st->codec;
344
    FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
345
    char args[255];
346
    int ret;
347

    
348
    graph = avfilter_graph_alloc();
349

    
350
    if ((ret = avfilter_open(&ist->input_video_filter, avfilter_get_by_name("buffer"), "src")) < 0)
351
        return ret;
352
    if ((ret = avfilter_open(&ist->output_video_filter, &ffsink, "out")) < 0)
353
        return ret;
354

    
355
    snprintf(args, 255, "%d:%d:%d:%d:%d", ist->st->codec->width,
356
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE);
357
    if ((ret = avfilter_init_filter(ist->input_video_filter, args, NULL)) < 0)
358
        return ret;
359
    if ((ret = avfilter_init_filter(ist->output_video_filter, NULL, &ffsink_ctx)) < 0)
360
        return ret;
361

    
362
    /* add input and output filters to the overall graph */
363
    avfilter_graph_add_filter(graph, ist->input_video_filter);
364
    avfilter_graph_add_filter(graph, ist->output_video_filter);
365

    
366
    last_filter = ist->input_video_filter;
367

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

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

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

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

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

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

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

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

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

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

    
426
static volatile int received_sigterm = 0;
427

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
547
    av_free(video_standard);
548

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

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

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

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

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

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

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

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

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

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

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

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

    
676
        s->nb_streams++;
677

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

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

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

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

    
710
        new_output_stream(s, nb_output_files);
711
    }
712

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

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

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

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

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

    
749
        bsfc= bsfc->next;
750
    }
751

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

    
759
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
760

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1108
    *frame_size = 0;
1109

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1332

    
1333
    oc = output_files[0];
1334

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

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

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

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

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

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

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

    
1413
        fflush(stderr);
1414
    }
1415

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1660
                        av_init_packet(&opkt);
1661

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1850

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2322
    /* init pts */
2323
    for(i=0;i<nb_istreams;i++) {
2324
        AVStream *st;
2325
        ist = ist_table[i];
2326
        st= ist->st;
2327
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2328
        ist->next_pts = AV_NOPTS_VALUE;
2329
        init_pts_correction(&ist->pts_ctx);
2330
        ist->is_start = 1;
2331
    }
2332

    
2333
    /* set meta data information from input file if required */
2334
    for (i=0;i<nb_meta_data_maps;i++) {
2335
        AVFormatContext *files[2];
2336
        AVMetadata      **meta[2];
2337
        AVMetadataTag *mtag;
2338
        int j;
2339

    
2340
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2341
        if ((index) < 0 || (index) >= (nb_elems)) {\
2342
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2343
                     (desc), (index));\
2344
            ret = AVERROR(EINVAL);\
2345
            goto dump_format;\
2346
        }
2347

    
2348
        int out_file_index = meta_data_maps[i][0].file;
2349
        int in_file_index = meta_data_maps[i][1].file;
2350
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2351
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2352

    
2353
        files[0] = output_files[out_file_index];
2354
        files[1] = input_files[in_file_index];
2355

    
2356
        for (j = 0; j < 2; j++) {
2357
            AVMetaDataMap *map = &meta_data_maps[i][j];
2358

    
2359
            switch (map->type) {
2360
            case 'g':
2361
                meta[j] = &files[j]->metadata;
2362
                break;
2363
            case 's':
2364
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2365
                meta[j] = &files[j]->streams[map->index]->metadata;
2366
                break;
2367
            case 'c':
2368
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2369
                meta[j] = &files[j]->chapters[map->index]->metadata;
2370
                break;
2371
            case 'p':
2372
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2373
                meta[j] = &files[j]->programs[map->index]->metadata;
2374
                break;
2375
            }
2376
        }
2377

    
2378
        mtag=NULL;
2379
        while((mtag=av_metadata_get(*meta[1], "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2380
            av_metadata_set2(meta[0], mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2381
    }
2382

    
2383
    /* copy chapters from the first input file that has them*/
2384
    for (i = 0; i < nb_input_files; i++) {
2385
        if (!input_files[i]->nb_chapters)
2386
            continue;
2387

    
2388
        for (j = 0; j < nb_output_files; j++)
2389
            if ((ret = copy_chapters(i, j)) < 0)
2390
                goto dump_format;
2391
    }
2392

    
2393
    /* open files and write file headers */
2394
    for(i=0;i<nb_output_files;i++) {
2395
        os = output_files[i];
2396
        if (av_write_header(os) < 0) {
2397
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2398
            ret = AVERROR(EINVAL);
2399
            goto dump_format;
2400
        }
2401
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2402
            want_sdp = 0;
2403
        }
2404
    }
2405

    
2406
 dump_format:
2407
    /* dump the file output parameters - cannot be done before in case
2408
       of stream copy */
2409
    for(i=0;i<nb_output_files;i++) {
2410
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2411
    }
2412

    
2413
    /* dump the stream mapping */
2414
    if (verbose >= 0) {
2415
        fprintf(stderr, "Stream mapping:\n");
2416
        for(i=0;i<nb_ostreams;i++) {
2417
            ost = ost_table[i];
2418
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2419
                    ist_table[ost->source_index]->file_index,
2420
                    ist_table[ost->source_index]->index,
2421
                    ost->file_index,
2422
                    ost->index);
2423
            if (ost->sync_ist != ist_table[ost->source_index])
2424
                fprintf(stderr, " [sync #%d.%d]",
2425
                        ost->sync_ist->file_index,
2426
                        ost->sync_ist->index);
2427
            fprintf(stderr, "\n");
2428
        }
2429
    }
2430

    
2431
    if (ret) {
2432
        fprintf(stderr, "%s\n", error);
2433
        goto fail;
2434
    }
2435

    
2436
    if (want_sdp) {
2437
        print_sdp(output_files, nb_output_files);
2438
    }
2439

    
2440
    if (!using_stdin && verbose >= 0) {
2441
        fprintf(stderr, "Press [q] to stop encoding\n");
2442
        url_set_interrupt_cb(decode_interrupt_cb);
2443
    }
2444
    term_init();
2445

    
2446
    timer_start = av_gettime();
2447

    
2448
    for(; received_sigterm == 0;) {
2449
        int file_index, ist_index;
2450
        AVPacket pkt;
2451
        double ipts_min;
2452
        double opts_min;
2453

    
2454
    redo:
2455
        ipts_min= 1e100;
2456
        opts_min= 1e100;
2457
        /* if 'q' pressed, exits */
2458
        if (!using_stdin) {
2459
            if (q_pressed)
2460
                break;
2461
            /* read_key() returns 0 on EOF */
2462
            key = read_key();
2463
            if (key == 'q')
2464
                break;
2465
        }
2466

    
2467
        /* select the stream that we must read now by looking at the
2468
           smallest output pts */
2469
        file_index = -1;
2470
        for(i=0;i<nb_ostreams;i++) {
2471
            double ipts, opts;
2472
            ost = ost_table[i];
2473
            os = output_files[ost->file_index];
2474
            ist = ist_table[ost->source_index];
2475
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2476
                continue;
2477
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2478
            ipts = (double)ist->pts;
2479
            if (!file_table[ist->file_index].eof_reached){
2480
                if(ipts < ipts_min) {
2481
                    ipts_min = ipts;
2482
                    if(input_sync ) file_index = ist->file_index;
2483
                }
2484
                if(opts < opts_min) {
2485
                    opts_min = opts;
2486
                    if(!input_sync) file_index = ist->file_index;
2487
                }
2488
            }
2489
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2490
                file_index= -1;
2491
                break;
2492
            }
2493
        }
2494
        /* if none, if is finished */
2495
        if (file_index < 0) {
2496
            if(no_packet_count){
2497
                no_packet_count=0;
2498
                memset(no_packet, 0, sizeof(no_packet));
2499
                usleep(10000);
2500
                continue;
2501
            }
2502
            break;
2503
        }
2504

    
2505
        /* finish if limit size exhausted */
2506
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2507
            break;
2508

    
2509
        /* read a frame from it and output it in the fifo */
2510
        is = input_files[file_index];
2511
        ret= av_read_frame(is, &pkt);
2512
        if(ret == AVERROR(EAGAIN)){
2513
            no_packet[file_index]=1;
2514
            no_packet_count++;
2515
            continue;
2516
        }
2517
        if (ret < 0) {
2518
            file_table[file_index].eof_reached = 1;
2519
            if (opt_shortest)
2520
                break;
2521
            else
2522
                continue;
2523
        }
2524

    
2525
        no_packet_count=0;
2526
        memset(no_packet, 0, sizeof(no_packet));
2527

    
2528
        if (do_pkt_dump) {
2529
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2530
        }
2531
        /* the following test is needed in case new streams appear
2532
           dynamically in stream : we ignore them */
2533
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2534
            goto discard_packet;
2535
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2536
        ist = ist_table[ist_index];
2537
        if (ist->discard)
2538
            goto discard_packet;
2539

    
2540
        if (pkt.dts != AV_NOPTS_VALUE)
2541
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2542
        if (pkt.pts != AV_NOPTS_VALUE)
2543
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2544

    
2545
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2546
            && input_files_ts_scale[file_index][pkt.stream_index]){
2547
            if(pkt.pts != AV_NOPTS_VALUE)
2548
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2549
            if(pkt.dts != AV_NOPTS_VALUE)
2550
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2551
        }
2552

    
2553
//        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);
2554
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2555
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2556
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2557
            int64_t delta= pkt_dts - ist->next_pts;
2558
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2559
                input_files_ts_offset[ist->file_index]-= delta;
2560
                if (verbose > 2)
2561
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2562
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2563
                if(pkt.pts != AV_NOPTS_VALUE)
2564
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2565
            }
2566
        }
2567

    
2568
        /* finish if recording time exhausted */
2569
        if (recording_time != INT64_MAX &&
2570
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2571
            ist->is_past_recording_time = 1;
2572
            goto discard_packet;
2573
        }
2574

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

    
2578
            if (verbose >= 0)
2579
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2580
                        ist->file_index, ist->index);
2581
            if (exit_on_error)
2582
                ffmpeg_exit(1);
2583
            av_free_packet(&pkt);
2584
            goto redo;
2585
        }
2586

    
2587
    discard_packet:
2588
        av_free_packet(&pkt);
2589

    
2590
        /* dump report by using the output first video and audio streams */
2591
        print_report(output_files, ost_table, nb_ostreams, 0);
2592
    }
2593

    
2594
    /* at the end of stream, we must flush the decoder buffers */
2595
    for(i=0;i<nb_istreams;i++) {
2596
        ist = ist_table[i];
2597
        if (ist->decoding_needed) {
2598
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2599
        }
2600
    }
2601

    
2602
    term_exit();
2603

    
2604
    /* write the trailer if needed and close file */
2605
    for(i=0;i<nb_output_files;i++) {
2606
        os = output_files[i];
2607
        av_write_trailer(os);
2608
    }
2609

    
2610
    /* dump report by using the first video and audio streams */
2611
    print_report(output_files, ost_table, nb_ostreams, 1);
2612

    
2613
    /* close each encoder */
2614
    for(i=0;i<nb_ostreams;i++) {
2615
        ost = ost_table[i];
2616
        if (ost->encoding_needed) {
2617
            av_freep(&ost->st->codec->stats_in);
2618
            avcodec_close(ost->st->codec);
2619
        }
2620
    }
2621

    
2622
    /* close each decoder */
2623
    for(i=0;i<nb_istreams;i++) {
2624
        ist = ist_table[i];
2625
        if (ist->decoding_needed) {
2626
            avcodec_close(ist->st->codec);
2627
        }
2628
    }
2629
#if CONFIG_AVFILTER
2630
    if (graph) {
2631
        avfilter_graph_free(graph);
2632
        av_freep(&graph);
2633
    }
2634
#endif
2635

    
2636
    /* finished ! */
2637
    ret = 0;
2638

    
2639
 fail:
2640
    av_freep(&bit_buffer);
2641
    av_free(file_table);
2642

    
2643
    if (ist_table) {
2644
        for(i=0;i<nb_istreams;i++) {
2645
            ist = ist_table[i];
2646
            av_free(ist);
2647
        }
2648
        av_free(ist_table);
2649
    }
2650
    if (ost_table) {
2651
        for(i=0;i<nb_ostreams;i++) {
2652
            ost = ost_table[i];
2653
            if (ost) {
2654
                if (ost->st->stream_copy)
2655
                    av_freep(&ost->st->codec->extradata);
2656
                if (ost->logfile) {
2657
                    fclose(ost->logfile);
2658
                    ost->logfile = NULL;
2659
                }
2660
                av_fifo_free(ost->fifo); /* works even if fifo is not
2661
                                             initialized but set to zero */
2662
                av_free(ost->pict_tmp.data[0]);
2663
                av_free(ost->forced_kf_pts);
2664
                if (ost->video_resample)
2665
                    sws_freeContext(ost->img_resample_ctx);
2666
                if (ost->resample)
2667
                    audio_resample_close(ost->resample);
2668
                if (ost->reformat_ctx)
2669
                    av_audio_convert_free(ost->reformat_ctx);
2670
                av_free(ost);
2671
            }
2672
        }
2673
        av_free(ost_table);
2674
    }
2675
    return ret;
2676
}
2677

    
2678
static void opt_format(const char *arg)
2679
{
2680
    last_asked_format = arg;
2681
}
2682

    
2683
static void opt_video_rc_override_string(const char *arg)
2684
{
2685
    video_rc_override_string = arg;
2686
}
2687

    
2688
static int opt_me_threshold(const char *opt, const char *arg)
2689
{
2690
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2691
    return 0;
2692
}
2693

    
2694
static int opt_verbose(const char *opt, const char *arg)
2695
{
2696
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2697
    return 0;
2698
}
2699

    
2700
static int opt_frame_rate(const char *opt, const char *arg)
2701
{
2702
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2703
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2704
        ffmpeg_exit(1);
2705
    }
2706
    return 0;
2707
}
2708

    
2709
static int opt_bitrate(const char *opt, const char *arg)
2710
{
2711
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2712

    
2713
    opt_default(opt, arg);
2714

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

    
2718
    return 0;
2719
}
2720

    
2721
static int opt_frame_crop(const char *opt, const char *arg)
2722
{
2723
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2724
    return AVERROR(EINVAL);
2725
}
2726

    
2727
static void opt_frame_size(const char *arg)
2728
{
2729
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2730
        fprintf(stderr, "Incorrect frame size\n");
2731
        ffmpeg_exit(1);
2732
    }
2733
}
2734

    
2735
static int opt_pad(const char *opt, const char *arg) {
2736
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2737
    return -1;
2738
}
2739

    
2740
static void opt_frame_pix_fmt(const char *arg)
2741
{
2742
    if (strcmp(arg, "list")) {
2743
        frame_pix_fmt = av_get_pix_fmt(arg);
2744
        if (frame_pix_fmt == PIX_FMT_NONE) {
2745
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2746
            ffmpeg_exit(1);
2747
        }
2748
    } else {
2749
        show_pix_fmts();
2750
        ffmpeg_exit(0);
2751
    }
2752
}
2753

    
2754
static void opt_frame_aspect_ratio(const char *arg)
2755
{
2756
    int x = 0, y = 0;
2757
    double ar = 0;
2758
    const char *p;
2759
    char *end;
2760

    
2761
    p = strchr(arg, ':');
2762
    if (p) {
2763
        x = strtol(arg, &end, 10);
2764
        if (end == p)
2765
            y = strtol(end+1, &end, 10);
2766
        if (x > 0 && y > 0)
2767
            ar = (double)x / (double)y;
2768
    } else
2769
        ar = strtod(arg, NULL);
2770

    
2771
    if (!ar) {
2772
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2773
        ffmpeg_exit(1);
2774
    }
2775
    frame_aspect_ratio = ar;
2776
}
2777

    
2778
static int opt_metadata(const char *opt, const char *arg)
2779
{
2780
    char *mid= strchr(arg, '=');
2781

    
2782
    if(!mid){
2783
        fprintf(stderr, "Missing =\n");
2784
        ffmpeg_exit(1);
2785
    }
2786
    *mid++= 0;
2787

    
2788
    av_metadata_set2(&metadata, arg, mid, 0);
2789

    
2790
    return 0;
2791
}
2792

    
2793
static void opt_qscale(const char *arg)
2794
{
2795
    video_qscale = atof(arg);
2796
    if (video_qscale <= 0 ||
2797
        video_qscale > 255) {
2798
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2799
        ffmpeg_exit(1);
2800
    }
2801
}
2802

    
2803
static void opt_top_field_first(const char *arg)
2804
{
2805
    top_field_first= atoi(arg);
2806
}
2807

    
2808
static int opt_thread_count(const char *opt, const char *arg)
2809
{
2810
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2811
#if !HAVE_THREADS
2812
    if (verbose >= 0)
2813
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2814
#endif
2815
    return 0;
2816
}
2817

    
2818
static void opt_audio_sample_fmt(const char *arg)
2819
{
2820
    if (strcmp(arg, "list"))
2821
        audio_sample_fmt = av_get_sample_fmt(arg);
2822
    else {
2823
        list_fmts(av_get_sample_fmt_string, SAMPLE_FMT_NB);
2824
        ffmpeg_exit(0);
2825
    }
2826
}
2827

    
2828
static int opt_audio_rate(const char *opt, const char *arg)
2829
{
2830
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2831
    return 0;
2832
}
2833

    
2834
static int opt_audio_channels(const char *opt, const char *arg)
2835
{
2836
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2837
    return 0;
2838
}
2839

    
2840
static void opt_video_channel(const char *arg)
2841
{
2842
    video_channel = strtol(arg, NULL, 0);
2843
}
2844

    
2845
static void opt_video_standard(const char *arg)
2846
{
2847
    video_standard = av_strdup(arg);
2848
}
2849

    
2850
static void opt_codec(int *pstream_copy, char **pcodec_name,
2851
                      int codec_type, const char *arg)
2852
{
2853
    av_freep(pcodec_name);
2854
    if (!strcmp(arg, "copy")) {
2855
        *pstream_copy = 1;
2856
    } else {
2857
        *pcodec_name = av_strdup(arg);
2858
    }
2859
}
2860

    
2861
static void opt_audio_codec(const char *arg)
2862
{
2863
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2864
}
2865

    
2866
static void opt_video_codec(const char *arg)
2867
{
2868
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2869
}
2870

    
2871
static void opt_subtitle_codec(const char *arg)
2872
{
2873
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2874
}
2875

    
2876
static int opt_codec_tag(const char *opt, const char *arg)
2877
{
2878
    char *tail;
2879
    uint32_t *codec_tag;
2880

    
2881
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2882
                !strcmp(opt, "vtag") ? &video_codec_tag :
2883
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2884
    if (!codec_tag)
2885
        return -1;
2886

    
2887
    *codec_tag = strtol(arg, &tail, 0);
2888
    if (!tail || *tail)
2889
        *codec_tag = AV_RL32(arg);
2890

    
2891
    return 0;
2892
}
2893

    
2894
static void opt_map(const char *arg)
2895
{
2896
    AVStreamMap *m;
2897
    char *p;
2898

    
2899
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2900
    m = &stream_maps[nb_stream_maps-1];
2901

    
2902
    m->file_index = strtol(arg, &p, 0);
2903
    if (*p)
2904
        p++;
2905

    
2906
    m->stream_index = strtol(p, &p, 0);
2907
    if (*p) {
2908
        p++;
2909
        m->sync_file_index = strtol(p, &p, 0);
2910
        if (*p)
2911
            p++;
2912
        m->sync_stream_index = strtol(p, &p, 0);
2913
    } else {
2914
        m->sync_file_index = m->file_index;
2915
        m->sync_stream_index = m->stream_index;
2916
    }
2917
}
2918

    
2919
static void parse_meta_type(const char *arg, char *type, int *index, char **endptr)
2920
{
2921
    *endptr = arg;
2922
    if (*arg == ',') {
2923
        *type = *(++arg);
2924
        switch (*arg) {
2925
        case 'g':
2926
            break;
2927
        case 's':
2928
        case 'c':
2929
        case 'p':
2930
            *index = strtol(++arg, endptr, 0);
2931
            break;
2932
        default:
2933
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2934
            ffmpeg_exit(1);
2935
        }
2936
    } else
2937
        *type = 'g';
2938
}
2939

    
2940
static void opt_map_meta_data(const char *arg)
2941
{
2942
    AVMetaDataMap *m, *m1;
2943
    char *p;
2944

    
2945
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2946
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
2947

    
2948
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
2949
    m->file = strtol(arg, &p, 0);
2950
    parse_meta_type(p, &m->type, &m->index, &p);
2951
    if (*p)
2952
        p++;
2953

    
2954
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2955
    m1->file = strtol(p, &p, 0);
2956
    parse_meta_type(p, &m1->type, &m1->index, &p);
2957

    
2958
    if (m->type == 's' || m1->type == 's')
2959
        metadata_streams_autocopy = 0;
2960
    if (m->type == 'c' || m1->type == 'c')
2961
        metadata_chapters_autocopy = 0;
2962
}
2963

    
2964
static void opt_input_ts_scale(const char *arg)
2965
{
2966
    unsigned int stream;
2967
    double scale;
2968
    char *p;
2969

    
2970
    stream = strtol(arg, &p, 0);
2971
    if (*p)
2972
        p++;
2973
    scale= strtod(p, &p);
2974

    
2975
    if(stream >= MAX_STREAMS)
2976
        ffmpeg_exit(1);
2977

    
2978
    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);
2979
    input_files_ts_scale[nb_input_files][stream]= scale;
2980
}
2981

    
2982
static int opt_recording_time(const char *opt, const char *arg)
2983
{
2984
    recording_time = parse_time_or_die(opt, arg, 1);
2985
    return 0;
2986
}
2987

    
2988
static int opt_start_time(const char *opt, const char *arg)
2989
{
2990
    start_time = parse_time_or_die(opt, arg, 1);
2991
    return 0;
2992
}
2993

    
2994
static int opt_recording_timestamp(const char *opt, const char *arg)
2995
{
2996
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2997
    return 0;
2998
}
2999

    
3000
static int opt_input_ts_offset(const char *opt, const char *arg)
3001
{
3002
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3003
    return 0;
3004
}
3005

    
3006
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3007
{
3008
    const char *codec_string = encoder ? "encoder" : "decoder";
3009
    AVCodec *codec;
3010

    
3011
    if(!name)
3012
        return CODEC_ID_NONE;
3013
    codec = encoder ?
3014
        avcodec_find_encoder_by_name(name) :
3015
        avcodec_find_decoder_by_name(name);
3016
    if(!codec) {
3017
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3018
        ffmpeg_exit(1);
3019
    }
3020
    if(codec->type != type) {
3021
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3022
        ffmpeg_exit(1);
3023
    }
3024
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3025
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3026
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3027
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3028
                codec_string, codec->name);
3029
        codec = encoder ?
3030
            avcodec_find_encoder(codec->id) :
3031
            avcodec_find_decoder(codec->id);
3032
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3033
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3034
                    codec_string, codec->name);
3035
        ffmpeg_exit(1);
3036
    }
3037
    return codec->id;
3038
}
3039

    
3040
static void opt_input_file(const char *filename)
3041
{
3042
    AVFormatContext *ic;
3043
    AVFormatParameters params, *ap = &params;
3044
    AVInputFormat *file_iformat = NULL;
3045
    int err, i, ret, rfps, rfps_base;
3046
    int64_t timestamp;
3047

    
3048
    if (last_asked_format) {
3049
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3050
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3051
            ffmpeg_exit(1);
3052
        }
3053
        last_asked_format = NULL;
3054
    }
3055

    
3056
    if (!strcmp(filename, "-"))
3057
        filename = "pipe:";
3058

    
3059
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3060
                    !strcmp(filename, "/dev/stdin");
3061

    
3062
    /* get default parameters from command line */
3063
    ic = avformat_alloc_context();
3064
    if (!ic) {
3065
        print_error(filename, AVERROR(ENOMEM));
3066
        ffmpeg_exit(1);
3067
    }
3068

    
3069
    memset(ap, 0, sizeof(*ap));
3070
    ap->prealloced_context = 1;
3071
    ap->sample_rate = audio_sample_rate;
3072
    ap->channels = audio_channels;
3073
    ap->time_base.den = frame_rate.num;
3074
    ap->time_base.num = frame_rate.den;
3075
    ap->width = frame_width;
3076
    ap->height = frame_height;
3077
    ap->pix_fmt = frame_pix_fmt;
3078
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3079
    ap->channel = video_channel;
3080
    ap->standard = video_standard;
3081

    
3082
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3083

    
3084
    ic->video_codec_id   =
3085
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3086
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3087
    ic->audio_codec_id   =
3088
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3089
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3090
    ic->subtitle_codec_id=
3091
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3092
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3093
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3094

    
3095
    /* open the input file with generic libav function */
3096
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3097
    if (err < 0) {
3098
        print_error(filename, err);
3099
        ffmpeg_exit(1);
3100
    }
3101
    if(opt_programid) {
3102
        int i, j;
3103
        int found=0;
3104
        for(i=0; i<ic->nb_streams; i++){
3105
            ic->streams[i]->discard= AVDISCARD_ALL;
3106
        }
3107
        for(i=0; i<ic->nb_programs; i++){
3108
            AVProgram *p= ic->programs[i];
3109
            if(p->id != opt_programid){
3110
                p->discard = AVDISCARD_ALL;
3111
            }else{
3112
                found=1;
3113
                for(j=0; j<p->nb_stream_indexes; j++){
3114
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3115
                }
3116
            }
3117
        }
3118
        if(!found){
3119
            fprintf(stderr, "Specified program id not found\n");
3120
            ffmpeg_exit(1);
3121
        }
3122
        opt_programid=0;
3123
    }
3124

    
3125
    ic->loop_input = loop_input;
3126

    
3127
    /* If not enough info to get the stream parameters, we decode the
3128
       first frames to get it. (used in mpeg case for example) */
3129
    ret = av_find_stream_info(ic);
3130
    if (ret < 0 && verbose >= 0) {
3131
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3132
        av_close_input_file(ic);
3133
        ffmpeg_exit(1);
3134
    }
3135

    
3136
    timestamp = start_time;
3137
    /* add the stream start time */
3138
    if (ic->start_time != AV_NOPTS_VALUE)
3139
        timestamp += ic->start_time;
3140

    
3141
    /* if seeking requested, we execute it */
3142
    if (start_time != 0) {
3143
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3144
        if (ret < 0) {
3145
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3146
                    filename, (double)timestamp / AV_TIME_BASE);
3147
        }
3148
        /* reset seek info */
3149
        start_time = 0;
3150
    }
3151

    
3152
    /* update the current parameters so that they match the one of the input stream */
3153
    for(i=0;i<ic->nb_streams;i++) {
3154
        AVStream *st = ic->streams[i];
3155
        AVCodecContext *dec = st->codec;
3156
        avcodec_thread_init(dec, thread_count);
3157
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3158
        switch (dec->codec_type) {
3159
        case AVMEDIA_TYPE_AUDIO:
3160
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3161
            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]);
3162
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3163
            channel_layout    = dec->channel_layout;
3164
            audio_channels    = dec->channels;
3165
            audio_sample_rate = dec->sample_rate;
3166
            audio_sample_fmt  = dec->sample_fmt;
3167
            if(audio_disable)
3168
                st->discard= AVDISCARD_ALL;
3169
            /* Note that av_find_stream_info can add more streams, and we
3170
             * currently have no chance of setting up lowres decoding
3171
             * early enough for them. */
3172
            if (dec->lowres)
3173
                audio_sample_rate >>= dec->lowres;
3174
            break;
3175
        case AVMEDIA_TYPE_VIDEO:
3176
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3177
            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]);
3178
            frame_height = dec->height;
3179
            frame_width  = dec->width;
3180
            if(ic->streams[i]->sample_aspect_ratio.num)
3181
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3182
            else
3183
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3184
            frame_aspect_ratio *= (float) dec->width / dec->height;
3185
            frame_pix_fmt = dec->pix_fmt;
3186
            rfps      = ic->streams[i]->r_frame_rate.num;
3187
            rfps_base = ic->streams[i]->r_frame_rate.den;
3188
            if (dec->lowres) {
3189
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3190
                frame_height >>= dec->lowres;
3191
                frame_width  >>= dec->lowres;
3192
            }
3193
            if(me_threshold)
3194
                dec->debug |= FF_DEBUG_MV;
3195

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

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

    
3202
                    (float)rfps / rfps_base, rfps, rfps_base);
3203
            }
3204
            /* update the current frame rate to match the stream frame rate */
3205
            frame_rate.num = rfps;
3206
            frame_rate.den = rfps_base;
3207

    
3208
            if(video_disable)
3209
                st->discard= AVDISCARD_ALL;
3210
            else if(video_discard)
3211
                st->discard= video_discard;
3212
            break;
3213
        case AVMEDIA_TYPE_DATA:
3214
            break;
3215
        case AVMEDIA_TYPE_SUBTITLE:
3216
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3217
            if(subtitle_disable)
3218
                st->discard = AVDISCARD_ALL;
3219
            break;
3220
        case AVMEDIA_TYPE_ATTACHMENT:
3221
        case AVMEDIA_TYPE_UNKNOWN:
3222
            break;
3223
        default:
3224
            abort();
3225
        }
3226
    }
3227

    
3228
    input_files[nb_input_files] = ic;
3229
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3230
    /* dump the file content */
3231
    if (verbose >= 0)
3232
        dump_format(ic, nb_input_files, filename, 0);
3233

    
3234
    nb_input_files++;
3235

    
3236
    video_channel = 0;
3237

    
3238
    av_freep(&video_codec_name);
3239
    av_freep(&audio_codec_name);
3240
    av_freep(&subtitle_codec_name);
3241
}
3242

    
3243
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3244
                                         int *has_subtitle_ptr)
3245
{
3246
    int has_video, has_audio, has_subtitle, i, j;
3247
    AVFormatContext *ic;
3248

    
3249
    has_video = 0;
3250
    has_audio = 0;
3251
    has_subtitle = 0;
3252
    for(j=0;j<nb_input_files;j++) {
3253
        ic = input_files[j];
3254
        for(i=0;i<ic->nb_streams;i++) {
3255
            AVCodecContext *enc = ic->streams[i]->codec;
3256
            switch(enc->codec_type) {
3257
            case AVMEDIA_TYPE_AUDIO:
3258
                has_audio = 1;
3259
                break;
3260
            case AVMEDIA_TYPE_VIDEO:
3261
                has_video = 1;
3262
                break;
3263
            case AVMEDIA_TYPE_SUBTITLE:
3264
                has_subtitle = 1;
3265
                break;
3266
            case AVMEDIA_TYPE_DATA:
3267
            case AVMEDIA_TYPE_ATTACHMENT:
3268
            case AVMEDIA_TYPE_UNKNOWN:
3269
                break;
3270
            default:
3271
                abort();
3272
            }
3273
        }
3274
    }
3275
    *has_video_ptr = has_video;
3276
    *has_audio_ptr = has_audio;
3277
    *has_subtitle_ptr = has_subtitle;
3278
}
3279

    
3280
static void new_video_stream(AVFormatContext *oc, int file_idx)
3281
{
3282
    AVStream *st;
3283
    AVOutputStream *ost;
3284
    AVCodecContext *video_enc;
3285
    enum CodecID codec_id;
3286
    AVCodec *codec= NULL;
3287

    
3288
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3289
    if (!st) {
3290
        fprintf(stderr, "Could not alloc stream\n");
3291
        ffmpeg_exit(1);
3292
    }
3293
    ost = new_output_stream(oc, file_idx);
3294

    
3295
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3296
    if(!video_stream_copy){
3297
        if (video_codec_name) {
3298
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3299
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3300
            codec = avcodec_find_encoder_by_name(video_codec_name);
3301
            output_codecs[nb_output_codecs-1] = codec;
3302
        } else {
3303
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3304
            codec = avcodec_find_encoder(codec_id);
3305
        }
3306
    }
3307

    
3308
    avcodec_get_context_defaults3(st->codec, codec);
3309
    ost->bitstream_filters = video_bitstream_filters;
3310
    video_bitstream_filters= NULL;
3311

    
3312
    avcodec_thread_init(st->codec, thread_count);
3313

    
3314
    video_enc = st->codec;
3315

    
3316
    if(video_codec_tag)
3317
        video_enc->codec_tag= video_codec_tag;
3318

    
3319
    if(   (video_global_header&1)
3320
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3321
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3322
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3323
    }
3324
    if(video_global_header&2){
3325
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3326
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3327
    }
3328

    
3329
    if (video_stream_copy) {
3330
        st->stream_copy = 1;
3331
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3332
        video_enc->sample_aspect_ratio =
3333
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3334
    } else {
3335
        const char *p;
3336
        int i;
3337
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3338

    
3339
        video_enc->codec_id = codec_id;
3340
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3341

    
3342
        if (codec && codec->supported_framerates && !force_fps)
3343
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3344
        video_enc->time_base.den = fps.num;
3345
        video_enc->time_base.num = fps.den;
3346

    
3347
        video_enc->width = frame_width;
3348
        video_enc->height = frame_height;
3349
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3350
        video_enc->pix_fmt = frame_pix_fmt;
3351
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3352

    
3353
        choose_pixel_fmt(st, codec);
3354

    
3355
        if (intra_only)
3356
            video_enc->gop_size = 0;
3357
        if (video_qscale || same_quality) {
3358
            video_enc->flags |= CODEC_FLAG_QSCALE;
3359
            video_enc->global_quality=
3360
                st->quality = FF_QP2LAMBDA * video_qscale;
3361
        }
3362

    
3363
        if(intra_matrix)
3364
            video_enc->intra_matrix = intra_matrix;
3365
        if(inter_matrix)
3366
            video_enc->inter_matrix = inter_matrix;
3367

    
3368
        p= video_rc_override_string;
3369
        for(i=0; p; i++){
3370
            int start, end, q;
3371
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3372
            if(e!=3){
3373
                fprintf(stderr, "error parsing rc_override\n");
3374
                ffmpeg_exit(1);
3375
            }
3376
            video_enc->rc_override=
3377
                av_realloc(video_enc->rc_override,
3378
                           sizeof(RcOverride)*(i+1));
3379
            video_enc->rc_override[i].start_frame= start;
3380
            video_enc->rc_override[i].end_frame  = end;
3381
            if(q>0){
3382
                video_enc->rc_override[i].qscale= q;
3383
                video_enc->rc_override[i].quality_factor= 1.0;
3384
            }
3385
            else{
3386
                video_enc->rc_override[i].qscale= 0;
3387
                video_enc->rc_override[i].quality_factor= -q/100.0;
3388
            }
3389
            p= strchr(p, '/');
3390
            if(p) p++;
3391
        }
3392
        video_enc->rc_override_count=i;
3393
        if (!video_enc->rc_initial_buffer_occupancy)
3394
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3395
        video_enc->me_threshold= me_threshold;
3396
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3397

    
3398
        if (do_psnr)
3399
            video_enc->flags|= CODEC_FLAG_PSNR;
3400

    
3401
        /* two pass mode */
3402
        if (do_pass) {
3403
            if (do_pass == 1) {
3404
                video_enc->flags |= CODEC_FLAG_PASS1;
3405
            } else {
3406
                video_enc->flags |= CODEC_FLAG_PASS2;
3407
            }
3408
        }
3409

    
3410
        if (forced_key_frames)
3411
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3412
    }
3413
    if (video_language) {
3414
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3415
        av_freep(&video_language);
3416
    }
3417

    
3418
    /* reset some key parameters */
3419
    video_disable = 0;
3420
    av_freep(&video_codec_name);
3421
    av_freep(&forced_key_frames);
3422
    video_stream_copy = 0;
3423
    frame_pix_fmt = PIX_FMT_NONE;
3424
}
3425

    
3426
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3427
{
3428
    AVStream *st;
3429
    AVOutputStream *ost;
3430
    AVCodec *codec= NULL;
3431
    AVCodecContext *audio_enc;
3432
    enum CodecID codec_id;
3433

    
3434
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3435
    if (!st) {
3436
        fprintf(stderr, "Could not alloc stream\n");
3437
        ffmpeg_exit(1);
3438
    }
3439
    ost = new_output_stream(oc, file_idx);
3440

    
3441
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3442
    if(!audio_stream_copy){
3443
        if (audio_codec_name) {
3444
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3445
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3446
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3447
            output_codecs[nb_output_codecs-1] = codec;
3448
        } else {
3449
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3450
            codec = avcodec_find_encoder(codec_id);
3451
        }
3452
    }
3453

    
3454
    avcodec_get_context_defaults3(st->codec, codec);
3455

    
3456
    ost->bitstream_filters = audio_bitstream_filters;
3457
    audio_bitstream_filters= NULL;
3458

    
3459
    avcodec_thread_init(st->codec, thread_count);
3460

    
3461
    audio_enc = st->codec;
3462
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3463

    
3464
    if(audio_codec_tag)
3465
        audio_enc->codec_tag= audio_codec_tag;
3466

    
3467
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3468
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3469
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3470
    }
3471
    if (audio_stream_copy) {
3472
        st->stream_copy = 1;
3473
        audio_enc->channels = audio_channels;
3474
        audio_enc->sample_rate = audio_sample_rate;
3475
    } else {
3476
        audio_enc->codec_id = codec_id;
3477
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3478

    
3479
        if (audio_qscale > QSCALE_NONE) {
3480
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3481
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3482
        }
3483
        audio_enc->channels = audio_channels;
3484
        audio_enc->sample_fmt = audio_sample_fmt;
3485
        audio_enc->sample_rate = audio_sample_rate;
3486
        audio_enc->channel_layout = channel_layout;
3487
        if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3488
            audio_enc->channel_layout = 0;
3489
        choose_sample_fmt(st, codec);
3490
        choose_sample_rate(st, codec);
3491
    }
3492
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3493
    if (audio_language) {
3494
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3495
        av_freep(&audio_language);
3496
    }
3497

    
3498
    /* reset some key parameters */
3499
    audio_disable = 0;
3500
    av_freep(&audio_codec_name);
3501
    audio_stream_copy = 0;
3502
}
3503

    
3504
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3505
{
3506
    AVStream *st;
3507
    AVOutputStream *ost;
3508
    AVCodec *codec=NULL;
3509
    AVCodecContext *subtitle_enc;
3510

    
3511
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3512
    if (!st) {
3513
        fprintf(stderr, "Could not alloc stream\n");
3514
        ffmpeg_exit(1);
3515
    }
3516
    ost = new_output_stream(oc, file_idx);
3517
    subtitle_enc = st->codec;
3518
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3519
    if(!subtitle_stream_copy){
3520
        subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3521
                                                   avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3522
        codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3523
    }
3524
    avcodec_get_context_defaults3(st->codec, codec);
3525

    
3526
    ost->bitstream_filters = subtitle_bitstream_filters;
3527
    subtitle_bitstream_filters= NULL;
3528

    
3529
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3530

    
3531
    if(subtitle_codec_tag)
3532
        subtitle_enc->codec_tag= subtitle_codec_tag;
3533

    
3534
    if (subtitle_stream_copy) {
3535
        st->stream_copy = 1;
3536
    } else {
3537
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3538
    }
3539

    
3540
    if (subtitle_language) {
3541
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3542
        av_freep(&subtitle_language);
3543
    }
3544

    
3545
    subtitle_disable = 0;
3546
    av_freep(&subtitle_codec_name);
3547
    subtitle_stream_copy = 0;
3548
}
3549

    
3550
static int opt_new_stream(const char *opt, const char *arg)
3551
{
3552
    AVFormatContext *oc;
3553
    int file_idx = nb_output_files - 1;
3554
    if (nb_output_files <= 0) {
3555
        fprintf(stderr, "At least one output file must be specified\n");
3556
        ffmpeg_exit(1);
3557
    }
3558
    oc = output_files[file_idx];
3559

    
3560
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3561
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3562
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3563
    else av_assert0(0);
3564
    return 0;
3565
}
3566

    
3567
/* arg format is "output-stream-index:streamid-value". */
3568
static int opt_streamid(const char *opt, const char *arg)
3569
{
3570
    int idx;
3571
    char *p;
3572
    char idx_str[16];
3573

    
3574
    strncpy(idx_str, arg, sizeof(idx_str));
3575
    idx_str[sizeof(idx_str)-1] = '\0';
3576
    p = strchr(idx_str, ':');
3577
    if (!p) {
3578
        fprintf(stderr,
3579
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3580
                arg, opt);
3581
        ffmpeg_exit(1);
3582
    }
3583
    *p++ = '\0';
3584
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3585
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3586
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3587
    return 0;
3588
}
3589

    
3590
static void opt_output_file(const char *filename)
3591
{
3592
    AVFormatContext *oc;
3593
    int err, use_video, use_audio, use_subtitle;
3594
    int input_has_video, input_has_audio, input_has_subtitle;
3595
    AVFormatParameters params, *ap = &params;
3596
    AVOutputFormat *file_oformat;
3597
    AVMetadataTag *tag = NULL;
3598

    
3599
    if (!strcmp(filename, "-"))
3600
        filename = "pipe:";
3601

    
3602
    oc = avformat_alloc_context();
3603
    if (!oc) {
3604
        print_error(filename, AVERROR(ENOMEM));
3605
        ffmpeg_exit(1);
3606
    }
3607

    
3608
    if (last_asked_format) {
3609
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3610
        if (!file_oformat) {
3611
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3612
            ffmpeg_exit(1);
3613
        }
3614
        last_asked_format = NULL;
3615
    } else {
3616
        file_oformat = av_guess_format(NULL, filename, NULL);
3617
        if (!file_oformat) {
3618
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3619
                    filename);
3620
            ffmpeg_exit(1);
3621
        }
3622
    }
3623

    
3624
    oc->oformat = file_oformat;
3625
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3626

    
3627
    if (!strcmp(file_oformat->name, "ffm") &&
3628
        av_strstart(filename, "http:", NULL)) {
3629
        /* special case for files sent to ffserver: we get the stream
3630
           parameters from ffserver */
3631
        int err = read_ffserver_streams(oc, filename);
3632
        if (err < 0) {
3633
            print_error(filename, err);
3634
            ffmpeg_exit(1);
3635
        }
3636
    } else {
3637
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3638
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3639
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3640

    
3641
        /* disable if no corresponding type found and at least one
3642
           input file */
3643
        if (nb_input_files > 0) {
3644
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3645
                                         &input_has_subtitle);
3646
            if (!input_has_video)
3647
                use_video = 0;
3648
            if (!input_has_audio)
3649
                use_audio = 0;
3650
            if (!input_has_subtitle)
3651
                use_subtitle = 0;
3652
        }
3653

    
3654
        /* manual disable */
3655
        if (audio_disable)    use_audio    = 0;
3656
        if (video_disable)    use_video    = 0;
3657
        if (subtitle_disable) use_subtitle = 0;
3658

    
3659
        if (use_video)    new_video_stream(oc, nb_output_files);
3660
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3661
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3662

    
3663
        oc->timestamp = recording_timestamp;
3664

    
3665
        while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
3666
            av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
3667
        av_metadata_free(&metadata);
3668
    }
3669

    
3670
    output_files[nb_output_files++] = oc;
3671

    
3672
    /* check filename in case of an image number is expected */
3673
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3674
        if (!av_filename_number_test(oc->filename)) {
3675
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3676
            ffmpeg_exit(1);
3677
        }
3678
    }
3679

    
3680
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3681
        /* test if it already exists to avoid loosing precious files */
3682
        if (!file_overwrite &&
3683
            (strchr(filename, ':') == NULL ||
3684
             filename[1] == ':' ||
3685
             av_strstart(filename, "file:", NULL))) {
3686
            if (url_exist(filename)) {
3687
                if (!using_stdin) {
3688
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3689
                    fflush(stderr);
3690
                    if (!read_yesno()) {
3691
                        fprintf(stderr, "Not overwriting - exiting\n");
3692
                        ffmpeg_exit(1);
3693
                    }
3694
                }
3695
                else {
3696
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3697
                    ffmpeg_exit(1);
3698
                }
3699
            }
3700
        }
3701

    
3702
        /* open the file */
3703
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3704
            print_error(filename, err);
3705
            ffmpeg_exit(1);
3706
        }
3707
    }
3708

    
3709
    memset(ap, 0, sizeof(*ap));
3710
    if (av_set_parameters(oc, ap) < 0) {
3711
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3712
                oc->filename);
3713
        ffmpeg_exit(1);
3714
    }
3715

    
3716
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3717
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3718
    oc->loop_output = loop_output;
3719
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3720

    
3721
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3722

    
3723
    nb_streamid_map = 0;
3724
    av_freep(&forced_key_frames);
3725
}
3726

    
3727
/* same option as mencoder */
3728
static void opt_pass(const char *pass_str)
3729
{
3730
    int pass;
3731
    pass = atoi(pass_str);
3732
    if (pass != 1 && pass != 2) {
3733
        fprintf(stderr, "pass number can be only 1 or 2\n");
3734
        ffmpeg_exit(1);
3735
    }
3736
    do_pass = pass;
3737
}
3738

    
3739
static int64_t getutime(void)
3740
{
3741
#if HAVE_GETRUSAGE
3742
    struct rusage rusage;
3743

    
3744
    getrusage(RUSAGE_SELF, &rusage);
3745
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3746
#elif HAVE_GETPROCESSTIMES
3747
    HANDLE proc;
3748
    FILETIME c, e, k, u;
3749
    proc = GetCurrentProcess();
3750
    GetProcessTimes(proc, &c, &e, &k, &u);
3751
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3752
#else
3753
    return av_gettime();
3754
#endif
3755
}
3756

    
3757
static int64_t getmaxrss(void)
3758
{
3759
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3760
    struct rusage rusage;
3761
    getrusage(RUSAGE_SELF, &rusage);
3762
    return (int64_t)rusage.ru_maxrss * 1024;
3763
#elif HAVE_GETPROCESSMEMORYINFO
3764
    HANDLE proc;
3765
    PROCESS_MEMORY_COUNTERS memcounters;
3766
    proc = GetCurrentProcess();
3767
    memcounters.cb = sizeof(memcounters);
3768
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3769
    return memcounters.PeakPagefileUsage;
3770
#else
3771
    return 0;
3772
#endif
3773
}
3774

    
3775
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3776
{
3777
    int i;
3778
    const char *p = str;
3779
    for(i = 0;; i++) {
3780
        dest[i] = atoi(p);
3781
        if(i == 63)
3782
            break;
3783
        p = strchr(p, ',');
3784
        if(!p) {
3785
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3786
            ffmpeg_exit(1);
3787
        }
3788
        p++;
3789
    }
3790
}
3791

    
3792
static void opt_inter_matrix(const char *arg)
3793
{
3794
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3795
    parse_matrix_coeffs(inter_matrix, arg);
3796
}
3797

    
3798
static void opt_intra_matrix(const char *arg)
3799
{
3800
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3801
    parse_matrix_coeffs(intra_matrix, arg);
3802
}
3803

    
3804
static void show_usage(void)
3805
{
3806
    printf("Hyper fast Audio and Video encoder\n");
3807
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3808
    printf("\n");
3809
}
3810

    
3811
static void show_help(void)
3812
{
3813
    av_log_set_callback(log_callback_help);
3814
    show_usage();
3815
    show_help_options(options, "Main options:\n",
3816
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3817
    show_help_options(options, "\nAdvanced options:\n",
3818
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3819
                      OPT_EXPERT);
3820
    show_help_options(options, "\nVideo options:\n",
3821
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3822
                      OPT_VIDEO);
3823
    show_help_options(options, "\nAdvanced Video options:\n",
3824
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3825
                      OPT_VIDEO | OPT_EXPERT);
3826
    show_help_options(options, "\nAudio options:\n",
3827
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3828
                      OPT_AUDIO);
3829
    show_help_options(options, "\nAdvanced Audio options:\n",
3830
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3831
                      OPT_AUDIO | OPT_EXPERT);
3832
    show_help_options(options, "\nSubtitle options:\n",
3833
                      OPT_SUBTITLE | OPT_GRAB,
3834
                      OPT_SUBTITLE);
3835
    show_help_options(options, "\nAudio/Video grab options:\n",
3836
                      OPT_GRAB,
3837
                      OPT_GRAB);
3838
    printf("\n");
3839
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3840
    printf("\n");
3841
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3842
    printf("\n");
3843
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3844
}
3845

    
3846
static void opt_target(const char *arg)
3847
{
3848
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3849
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3850

    
3851
    if(!strncmp(arg, "pal-", 4)) {
3852
        norm = PAL;
3853
        arg += 4;
3854
    } else if(!strncmp(arg, "ntsc-", 5)) {
3855
        norm = NTSC;
3856
        arg += 5;
3857
    } else if(!strncmp(arg, "film-", 5)) {
3858
        norm = FILM;
3859
        arg += 5;
3860
    } else {
3861
        int fr;
3862
        /* Calculate FR via float to avoid int overflow */
3863
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3864
        if(fr == 25000) {
3865
            norm = PAL;
3866
        } else if((fr == 29970) || (fr == 23976)) {
3867
            norm = NTSC;
3868
        } else {
3869
            /* Try to determine PAL/NTSC by peeking in the input files */
3870
            if(nb_input_files) {
3871
                int i, j;
3872
                for(j = 0; j < nb_input_files; j++) {
3873
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3874
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3875
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3876
                            continue;
3877
                        fr = c->time_base.den * 1000 / c->time_base.num;
3878
                        if(fr == 25000) {
3879
                            norm = PAL;
3880
                            break;
3881
                        } else if((fr == 29970) || (fr == 23976)) {
3882
                            norm = NTSC;
3883
                            break;
3884
                        }
3885
                    }
3886
                    if(norm != UNKNOWN)
3887
                        break;
3888
                }
3889
            }
3890
        }
3891
        if(verbose && norm != UNKNOWN)
3892
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3893
    }
3894

    
3895
    if(norm == UNKNOWN) {
3896
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3897
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3898
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3899
        ffmpeg_exit(1);
3900
    }
3901

    
3902
    if(!strcmp(arg, "vcd")) {
3903

    
3904
        opt_video_codec("mpeg1video");
3905
        opt_audio_codec("mp2");
3906
        opt_format("vcd");
3907

    
3908
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
3909
        opt_frame_rate(NULL, frame_rates[norm]);
3910
        opt_default("g", norm == PAL ? "15" : "18");
3911

    
3912
        opt_default("b", "1150000");
3913
        opt_default("maxrate", "1150000");
3914
        opt_default("minrate", "1150000");
3915
        opt_default("bufsize", "327680"); // 40*1024*8;
3916

    
3917
        opt_default("ab", "224000");
3918
        audio_sample_rate = 44100;
3919
        audio_channels = 2;
3920

    
3921
        opt_default("packetsize", "2324");
3922
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3923

    
3924
        /* We have to offset the PTS, so that it is consistent with the SCR.
3925
           SCR starts at 36000, but the first two packs contain only padding
3926
           and the first pack from the other stream, respectively, may also have
3927
           been written before.
3928
           So the real data starts at SCR 36000+3*1200. */
3929
        mux_preload= (36000+3*1200) / 90000.0; //0.44
3930
    } else if(!strcmp(arg, "svcd")) {
3931

    
3932
        opt_video_codec("mpeg2video");
3933
        opt_audio_codec("mp2");
3934
        opt_format("svcd");
3935

    
3936
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
3937
        opt_frame_rate(NULL, frame_rates[norm]);
3938
        opt_default("g", norm == PAL ? "15" : "18");
3939

    
3940
        opt_default("b", "2040000");
3941
        opt_default("maxrate", "2516000");
3942
        opt_default("minrate", "0"); //1145000;
3943
        opt_default("bufsize", "1835008"); //224*1024*8;
3944
        opt_default("flags", "+scan_offset");
3945

    
3946

    
3947
        opt_default("ab", "224000");
3948
        audio_sample_rate = 44100;
3949

    
3950
        opt_default("packetsize", "2324");
3951

    
3952
    } else if(!strcmp(arg, "dvd")) {
3953

    
3954
        opt_video_codec("mpeg2video");
3955
        opt_audio_codec("ac3");
3956
        opt_format("dvd");
3957

    
3958
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3959
        opt_frame_rate(NULL, frame_rates[norm]);
3960
        opt_default("g", norm == PAL ? "15" : "18");
3961

    
3962
        opt_default("b", "6000000");
3963
        opt_default("maxrate", "9000000");
3964
        opt_default("minrate", "0"); //1500000;
3965
        opt_default("bufsize", "1835008"); //224*1024*8;
3966

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

    
3970
        opt_default("ab", "448000");
3971
        audio_sample_rate = 48000;
3972

    
3973
    } else if(!strncmp(arg, "dv", 2)) {
3974

    
3975
        opt_format("dv");
3976

    
3977
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
3978
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3979
                          (norm == PAL ? "yuv420p" : "yuv411p"));
3980
        opt_frame_rate(NULL, frame_rates[norm]);
3981

    
3982
        audio_sample_rate = 48000;
3983
        audio_channels = 2;
3984

    
3985
    } else {
3986
        fprintf(stderr, "Unknown target: %s\n", arg);
3987
        ffmpeg_exit(1);
3988
    }
3989
}
3990

    
3991
static void opt_vstats_file (const char *arg)
3992
{
3993
    av_free (vstats_filename);
3994
    vstats_filename=av_strdup (arg);
3995
}
3996

    
3997
static void opt_vstats (void)
3998
{
3999
    char filename[40];
4000
    time_t today2 = time(NULL);
4001
    struct tm *today = localtime(&today2);
4002

    
4003
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4004
             today->tm_sec);
4005
    opt_vstats_file(filename);
4006
}
4007

    
4008
static int opt_bsf(const char *opt, const char *arg)
4009
{
4010
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4011
    AVBitStreamFilterContext **bsfp;
4012

    
4013
    if(!bsfc){
4014
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4015
        ffmpeg_exit(1);
4016
    }
4017

    
4018
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4019
          *opt == 'a' ? &audio_bitstream_filters :
4020
                        &subtitle_bitstream_filters;
4021
    while(*bsfp)
4022
        bsfp= &(*bsfp)->next;
4023

    
4024
    *bsfp= bsfc;
4025

    
4026
    return 0;
4027
}
4028

    
4029
static int opt_preset(const char *opt, const char *arg)
4030
{
4031
    FILE *f=NULL;
4032
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4033
    int i;
4034
    const char *base[3]= { getenv("FFMPEG_DATADIR"),
4035
                           getenv("HOME"),
4036
                           FFMPEG_DATADIR,
4037
                         };
4038

    
4039
    if (*opt != 'f') {
4040
        for(i=0; i<3 && !f; i++){
4041
            if(!base[i])
4042
                continue;
4043
            snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg);
4044
            f= fopen(filename, "r");
4045
            if(!f){
4046
                char *codec_name= *opt == 'v' ? video_codec_name :
4047
                                  *opt == 'a' ? audio_codec_name :
4048
                                                subtitle_codec_name;
4049
                snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, arg);
4050
                f= fopen(filename, "r");
4051
            }
4052
        }
4053
    } else {
4054
        av_strlcpy(filename, arg, sizeof(filename));
4055
        f= fopen(filename, "r");
4056
    }
4057

    
4058
    if(!f){
4059
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4060
        ffmpeg_exit(1);
4061
    }
4062

    
4063
    while(!feof(f)){
4064
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4065
        if(line[0] == '#' && !e)
4066
            continue;
4067
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4068
        if(e){
4069
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4070
            ffmpeg_exit(1);
4071
        }
4072
        if(!strcmp(tmp, "acodec")){
4073
            opt_audio_codec(tmp2);
4074
        }else if(!strcmp(tmp, "vcodec")){
4075
            opt_video_codec(tmp2);
4076
        }else if(!strcmp(tmp, "scodec")){
4077
            opt_subtitle_codec(tmp2);
4078
        }else if(opt_default(tmp, tmp2) < 0){
4079
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4080
            ffmpeg_exit(1);
4081
        }
4082
    }
4083

    
4084
    fclose(f);
4085

    
4086
    return 0;
4087
}
4088

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

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

    
4177
    /* audio options */
4178
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4179
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4180
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4181
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4182
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4183
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4184
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4185
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4186
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4187
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4188
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4189
    { "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" },
4190

    
4191
    /* subtitle options */
4192
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4193
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4194
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4195
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4196
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4197

    
4198
    /* grab options */
4199
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4200
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4201
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4202

    
4203
    /* muxer options */
4204
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4205
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4206

    
4207
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4208
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4209
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4210

    
4211
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4212
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4213
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4214
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4215

    
4216
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4217
    { NULL, },
4218
};
4219

    
4220
int main(int argc, char **argv)
4221
{
4222
    int64_t ti;
4223

    
4224
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4225

    
4226
    avcodec_register_all();
4227
#if CONFIG_AVDEVICE
4228
    avdevice_register_all();
4229
#endif
4230
#if CONFIG_AVFILTER
4231
    avfilter_register_all();
4232
#endif
4233
    av_register_all();
4234

    
4235
#if HAVE_ISATTY
4236
    if(isatty(STDIN_FILENO))
4237
        url_set_interrupt_cb(decode_interrupt_cb);
4238
#endif
4239

    
4240
    init_opts();
4241

    
4242
    show_banner();
4243

    
4244
    /* parse options */
4245
    parse_options(argc, argv, options, opt_output_file);
4246

    
4247
    if(nb_output_files <= 0 && nb_input_files == 0) {
4248
        show_usage();
4249
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4250
        ffmpeg_exit(1);
4251
    }
4252

    
4253
    /* file converter / grab */
4254
    if (nb_output_files <= 0) {
4255
        fprintf(stderr, "At least one output file must be specified\n");
4256
        ffmpeg_exit(1);
4257
    }
4258

    
4259
    if (nb_input_files == 0) {
4260
        fprintf(stderr, "At least one input file must be specified\n");
4261
        ffmpeg_exit(1);
4262
    }
4263

    
4264
    ti = getutime();
4265
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4266
                  stream_maps, nb_stream_maps) < 0)
4267
        ffmpeg_exit(1);
4268
    ti = getutime() - ti;
4269
    if (do_benchmark) {
4270
        int maxrss = getmaxrss() / 1024;
4271
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4272
    }
4273

    
4274
    return ffmpeg_exit(0);
4275
}