Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ a6d1bd05

History | View | Annotate | Download (159 KB)

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

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

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

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

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

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

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

    
82
#include "cmdutils.h"
83

    
84
#include "libavutil/avassert.h"
85

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

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

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

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

    
111
static const OptionDef options[];
112

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

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

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

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

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

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

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

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

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

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

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

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

    
224
static int rate_emu = 0;
225

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

    
229
static int audio_volume = 256;
230

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

    
246
static float dts_delta_threshold = 10;
247

    
248
static unsigned int sws_flags = SWS_BICUBIC;
249

    
250
static int64_t timer_start;
251

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

    
256
static short *samples;
257

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

    
262
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
263

    
264
struct AVInputStream;
265

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

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

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

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

    
308
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
309
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
310

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

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

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

    
343
#if HAVE_TERMIOS_H
344

    
345
/* init terminal so that we can grab keys */
346
static struct termios oldtty;
347
#endif
348

    
349
#if CONFIG_AVFILTER
350

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

    
361
    graph = avfilter_graph_alloc();
362

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

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

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

    
391
    if (vfilters) {
392
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
393
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
394

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

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

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

    
413
    if ((ret = avfilter_graph_config(graph, NULL)) < 0)
414
        return ret;
415

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

    
419
    return 0;
420
}
421
#endif /* CONFIG_AVFILTER */
422

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

    
431
static volatile int received_sigterm = 0;
432

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

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

    
445
    tcgetattr (0, &tty);
446
    oldtty = tty;
447
    atexit(term_exit);
448

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

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

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

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

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

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

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

    
502
static int ffmpeg_exit(int ret)
503
{
504
    int i;
505

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

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

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

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

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

    
552
    av_free(video_standard);
553

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

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

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

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

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

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

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

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

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

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

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

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

    
684
        s->nb_streams++;
685

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

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

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

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

    
718
        new_output_stream(s, nb_output_files);
719
    }
720

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

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

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

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

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

    
757
        bsfc= bsfc->next;
758
    }
759

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

    
767
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
768

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

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

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

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

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

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

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

    
812
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
813
                       ost->resample_channels    != dec->channels   ||
814
                       ost->resample_sample_rate != dec->sample_rate;
815

    
816
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
817
        if (resample_changed) {
818
            av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
819
                   ist->file_index, ist->index,
820
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
821
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
822
            ost->resample_sample_fmt  = dec->sample_fmt;
823
            ost->resample_channels    = dec->channels;
824
            ost->resample_sample_rate = dec->sample_rate;
825
            if (ost->resample)
826
                audio_resample_close(ost->resample);
827
        }
828
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
829
        if (audio_sync_method <= 1 &&
830
            ost->resample_sample_fmt  == enc->sample_fmt &&
831
            ost->resample_channels    == enc->channels   &&
832
            ost->resample_sample_rate == enc->sample_rate) {
833
            ost->resample = NULL;
834
            ost->audio_resample = 0;
835
        } else {
836
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
837
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
838
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
839
                                                   enc->sample_rate, dec->sample_rate,
840
                                                   enc->sample_fmt,  dec->sample_fmt,
841
                                                   16, 10, 0, 0.8);
842
            if (!ost->resample) {
843
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
844
                        dec->channels, dec->sample_rate,
845
                        enc->channels, enc->sample_rate);
846
                ffmpeg_exit(1);
847
            }
848
        }
849
    }
850

    
851
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
852
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
853
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
854
        if (ost->reformat_ctx)
855
            av_audio_convert_free(ost->reformat_ctx);
856
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
857
                                                   dec->sample_fmt, 1, NULL, 0);
858
        if (!ost->reformat_ctx) {
859
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
860
                av_get_sample_fmt_name(dec->sample_fmt),
861
                av_get_sample_fmt_name(enc->sample_fmt));
862
            ffmpeg_exit(1);
863
        }
864
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
865
    }
866

    
867
    if(audio_sync_method){
868
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
869
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
870
        double idelta= delta*dec->sample_rate / enc->sample_rate;
871
        int byte_delta= ((int)idelta)*2*dec->channels;
872

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

    
889
                    if(byte_delta > allocated_for_size - size){
890
                        allocated_for_size= byte_delta + (int64_t)size;
891
                        goto need_realloc;
892
                    }
893
                    ist->is_start=0;
894

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

    
915
    if (ost->audio_resample) {
916
        buftmp = audio_buf;
917
        size_out = audio_resample(ost->resample,
918
                                  (short *)buftmp, (short *)buf,
919
                                  size / (dec->channels * isize));
920
        size_out = size_out * enc->channels * osize;
921
    } else {
922
        buftmp = buf;
923
        size_out = size;
924
    }
925

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

    
942
    /* now encode as many frames as possible */
943
    if (enc->frame_size > 1) {
944
        /* output resampled raw samples */
945
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
946
            fprintf(stderr, "av_fifo_realloc2() failed\n");
947
            ffmpeg_exit(1);
948
        }
949
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
950

    
951
        frame_bytes = enc->frame_size * osize * enc->channels;
952

    
953
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
954
            AVPacket pkt;
955
            av_init_packet(&pkt);
956

    
957
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
958

    
959
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
960

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

    
976
            ost->sync_opts += enc->frame_size;
977
        }
978
    } else {
979
        AVPacket pkt;
980
        av_init_packet(&pkt);
981

    
982
        ost->sync_opts += size_out / (osize * enc->channels);
983

    
984
        /* output a pcm frame */
985
        /* determine the size of the coded buffer */
986
        size_out /= osize;
987
        if (coded_bps)
988
            size_out = size_out*coded_bps/8;
989

    
990
        if(size_out > audio_out_size){
991
            fprintf(stderr, "Internal error, buffer size too small\n");
992
            ffmpeg_exit(1);
993
        }
994

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

    
1013
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1014
{
1015
    AVCodecContext *dec;
1016
    AVPicture *picture2;
1017
    AVPicture picture_tmp;
1018
    uint8_t *buf = 0;
1019

    
1020
    dec = ist->st->codec;
1021

    
1022
    /* deinterlace : must be done before any resize */
1023
    if (do_deinterlace) {
1024
        int size;
1025

    
1026
        /* create temporary picture */
1027
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1028
        buf = av_malloc(size);
1029
        if (!buf)
1030
            return;
1031

    
1032
        picture2 = &picture_tmp;
1033
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1034

    
1035
        if(avpicture_deinterlace(picture2, picture,
1036
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1037
            /* if error, do not deinterlace */
1038
            fprintf(stderr, "Deinterlacing failed\n");
1039
            av_free(buf);
1040
            buf = NULL;
1041
            picture2 = picture;
1042
        }
1043
    } else {
1044
        picture2 = picture;
1045
    }
1046

    
1047
    if (picture != picture2)
1048
        *picture = *picture2;
1049
    *bufp = buf;
1050
}
1051

    
1052
/* we begin to correct av delay at this threshold */
1053
#define AV_DELAY_MAX 0.100
1054

    
1055
static void do_subtitle_out(AVFormatContext *s,
1056
                            AVOutputStream *ost,
1057
                            AVInputStream *ist,
1058
                            AVSubtitle *sub,
1059
                            int64_t pts)
1060
{
1061
    static uint8_t *subtitle_out = NULL;
1062
    int subtitle_out_max_size = 1024 * 1024;
1063
    int subtitle_out_size, nb, i;
1064
    AVCodecContext *enc;
1065
    AVPacket pkt;
1066

    
1067
    if (pts == AV_NOPTS_VALUE) {
1068
        fprintf(stderr, "Subtitle packets must have a pts\n");
1069
        if (exit_on_error)
1070
            ffmpeg_exit(1);
1071
        return;
1072
    }
1073

    
1074
    enc = ost->st->codec;
1075

    
1076
    if (!subtitle_out) {
1077
        subtitle_out = av_malloc(subtitle_out_max_size);
1078
    }
1079

    
1080
    /* Note: DVB subtitle need one packet to draw them and one other
1081
       packet to clear them */
1082
    /* XXX: signal it in the codec context ? */
1083
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1084
        nb = 2;
1085
    else
1086
        nb = 1;
1087

    
1088
    for(i = 0; i < nb; i++) {
1089
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1090
        // start_display_time is required to be 0
1091
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1092
        sub->end_display_time -= sub->start_display_time;
1093
        sub->start_display_time = 0;
1094
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1095
                                                    subtitle_out_max_size, sub);
1096
        if (subtitle_out_size < 0) {
1097
            fprintf(stderr, "Subtitle encoding failed\n");
1098
            ffmpeg_exit(1);
1099
        }
1100

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

    
1118
static int bit_buffer_size= 1024*256;
1119
static uint8_t *bit_buffer= NULL;
1120

    
1121
static void do_video_out(AVFormatContext *s,
1122
                         AVOutputStream *ost,
1123
                         AVInputStream *ist,
1124
                         AVFrame *in_picture,
1125
                         int *frame_size)
1126
{
1127
    int nb_frames, i, ret;
1128
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1129
    AVCodecContext *enc, *dec;
1130
    double sync_ipts;
1131

    
1132
    enc = ost->st->codec;
1133
    dec = ist->st->codec;
1134

    
1135
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1136

    
1137
    /* by default, we output a single frame */
1138
    nb_frames = 1;
1139

    
1140
    *frame_size = 0;
1141

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

    
1167
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1168
    if (nb_frames <= 0)
1169
        return;
1170

    
1171
    formatted_picture = in_picture;
1172
    final_picture = formatted_picture;
1173
    padding_src = formatted_picture;
1174
    resampling_dst = &ost->pict_tmp;
1175

    
1176
    if (   ost->resample_height != ist->st->codec->height
1177
        || ost->resample_width  != ist->st->codec->width
1178
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1179

    
1180
        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));
1181
        if(!ost->video_resample)
1182
            ffmpeg_exit(1);
1183
    }
1184

    
1185
#if !CONFIG_AVFILTER
1186
    if (ost->video_resample) {
1187
        padding_src = NULL;
1188
        final_picture = &ost->pict_tmp;
1189
        if(  ost->resample_height != ist->st->codec->height
1190
          || ost->resample_width  != ist->st->codec->width
1191
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1192

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

    
1214
    /* duplicates frame if needed */
1215
    for(i=0;i<nb_frames;i++) {
1216
        AVPacket pkt;
1217
        av_init_packet(&pkt);
1218
        pkt.stream_index= ost->index;
1219

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

    
1231
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1232
            enc->coded_frame = old_frame;
1233
        } else {
1234
            AVFrame big_picture;
1235

    
1236
            big_picture= *final_picture;
1237
            /* better than nothing: use input picture interlaced
1238
               settings */
1239
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1240
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1241
                if(top_field_first == -1)
1242
                    big_picture.top_field_first = in_picture->top_field_first;
1243
                else
1244
                    big_picture.top_field_first = top_field_first;
1245
            }
1246

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

    
1269
            if(ret>0){
1270
                pkt.data= bit_buffer;
1271
                pkt.size= ret;
1272
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1273
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1274
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1275
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1276
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1277

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

    
1296
static double psnr(double d){
1297
    return -10.0*log(d)/log(10.0);
1298
}
1299

    
1300
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1301
                           int frame_size)
1302
{
1303
    AVCodecContext *enc;
1304
    int frame_number;
1305
    double ti1, bitrate, avg_bitrate;
1306

    
1307
    /* this is executed just the first time do_video_stats is called */
1308
    if (!vstats_file) {
1309
        vstats_file = fopen(vstats_filename, "w");
1310
        if (!vstats_file) {
1311
            perror("fopen");
1312
            ffmpeg_exit(1);
1313
        }
1314
    }
1315

    
1316
    enc = ost->st->codec;
1317
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1318
        frame_number = ost->frame_number;
1319
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1320
        if (enc->flags&CODEC_FLAG_PSNR)
1321
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1322

    
1323
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1324
        /* compute pts value */
1325
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1326
        if (ti1 < 0.01)
1327
            ti1 = 0.01;
1328

    
1329
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1330
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1331
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1332
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1333
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1334
    }
1335
}
1336

    
1337
static void print_report(AVFormatContext **output_files,
1338
                         AVOutputStream **ost_table, int nb_ostreams,
1339
                         int is_last_report)
1340
{
1341
    char buf[1024];
1342
    AVOutputStream *ost;
1343
    AVFormatContext *oc;
1344
    int64_t total_size;
1345
    AVCodecContext *enc;
1346
    int frame_number, vid, i;
1347
    double bitrate, ti1, pts;
1348
    static int64_t last_time = -1;
1349
    static int qp_histogram[52];
1350

    
1351
    if (!is_last_report) {
1352
        int64_t cur_time;
1353
        /* display the report every 0.5 seconds */
1354
        cur_time = av_gettime();
1355
        if (last_time == -1) {
1356
            last_time = cur_time;
1357
            return;
1358
        }
1359
        if ((cur_time - last_time) < 500000)
1360
            return;
1361
        last_time = cur_time;
1362
    }
1363

    
1364

    
1365
    oc = output_files[0];
1366

    
1367
    total_size = url_fsize(oc->pb);
1368
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1369
        total_size= url_ftell(oc->pb);
1370

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

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

    
1431
    if (verbose || is_last_report) {
1432
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1433

    
1434
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1435
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1436
            (double)total_size / 1024, ti1, bitrate);
1437

    
1438
        if (nb_frames_dup || nb_frames_drop)
1439
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1440
                  nb_frames_dup, nb_frames_drop);
1441

    
1442
        if (verbose >= 0)
1443
            fprintf(stderr, "%s    \r", buf);
1444

    
1445
        fflush(stderr);
1446
    }
1447

    
1448
    if (is_last_report && verbose >= 0){
1449
        int64_t raw= audio_size + video_size + extra_size;
1450
        fprintf(stderr, "\n");
1451
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1452
                video_size/1024.0,
1453
                audio_size/1024.0,
1454
                extra_size/1024.0,
1455
                100.0*(total_size - raw)/raw
1456
        );
1457
    }
1458
}
1459

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

    
1478
    AVPacket avpkt;
1479
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1480

    
1481
    if(ist->next_pts == AV_NOPTS_VALUE)
1482
        ist->next_pts= ist->pts;
1483

    
1484
    if (pkt == NULL) {
1485
        /* EOF handling */
1486
        av_init_packet(&avpkt);
1487
        avpkt.data = NULL;
1488
        avpkt.size = 0;
1489
        goto handle_eof;
1490
    } else {
1491
        avpkt = *pkt;
1492
    }
1493

    
1494
    if(pkt->dts != AV_NOPTS_VALUE)
1495
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1496
    if(pkt->pts != AV_NOPTS_VALUE)
1497
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1498

    
1499
    //while we have more to decode or while the decoder did output something on EOF
1500
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1501
        uint8_t *data_buf, *decoded_data_buf;
1502
        int data_size, decoded_data_size;
1503
    handle_eof:
1504
        ist->pts= ist->next_pts;
1505

    
1506
        if(avpkt.size && avpkt.size != pkt->size &&
1507
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1508
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1509
            ist->showed_multi_packet_warning=1;
1510
        }
1511

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

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

    
1604
        buffer_to_free = NULL;
1605
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1606
            pre_process_video_frame(ist, (AVPicture *)&picture,
1607
                                    &buffer_to_free);
1608
        }
1609

    
1610
#if CONFIG_AVFILTER
1611
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1612
            AVRational sar;
1613
            if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1614
            else                                  sar = ist->st->codec->sample_aspect_ratio;
1615
            // add it to be filtered
1616
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1617
                                     ist->pts,
1618
                                     sar);
1619
        }
1620
#endif
1621

    
1622
        // preprocess audio (volume)
1623
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1624
            if (audio_volume != 256) {
1625
                short *volp;
1626
                volp = samples;
1627
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1628
                    int v = ((*volp) * audio_volume + 128) >> 8;
1629
                    if (v < -32768) v = -32768;
1630
                    if (v >  32767) v = 32767;
1631
                    *volp++ = v;
1632
                }
1633
            }
1634
        }
1635

    
1636
        /* frame rate emulation */
1637
        if (rate_emu) {
1638
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1639
            int64_t now = av_gettime() - ist->start;
1640
            if (pts > now)
1641
                usleep(pts - now);
1642
        }
1643
#if CONFIG_AVFILTER
1644
        frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1645
            !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1646
#endif
1647
        /* if output time reached then transcode raw format,
1648
           encode packets and output them */
1649
        if (start_time == 0 || ist->pts >= start_time)
1650
#if CONFIG_AVFILTER
1651
        while (frame_available) {
1652
            AVRational ist_pts_tb;
1653
            if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1654
                get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1655
            if (ist->picref)
1656
                ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1657
#endif
1658
            for(i=0;i<nb_ostreams;i++) {
1659
                int frame_size;
1660

    
1661
                ost = ost_table[i];
1662
                if (ost->source_index == ist_index) {
1663
                    os = output_files[ost->file_index];
1664

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

    
1668
                    if (ost->encoding_needed) {
1669
                        av_assert0(ist->decoding_needed);
1670
                        switch(ost->st->codec->codec_type) {
1671
                        case AVMEDIA_TYPE_AUDIO:
1672
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1673
                            break;
1674
                        case AVMEDIA_TYPE_VIDEO:
1675
#if CONFIG_AVFILTER
1676
                            if (ist->picref->video)
1677
                                ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1678
#endif
1679
                            do_video_out(os, ost, ist, &picture, &frame_size);
1680
                            if (vstats_filename && frame_size)
1681
                                do_video_stats(os, ost, frame_size);
1682
                            break;
1683
                        case AVMEDIA_TYPE_SUBTITLE:
1684
                            do_subtitle_out(os, ost, ist, &subtitle,
1685
                                            pkt->pts);
1686
                            break;
1687
                        default:
1688
                            abort();
1689
                        }
1690
                    } else {
1691
                        AVFrame avframe; //FIXME/XXX remove this
1692
                        AVPacket opkt;
1693
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1694

    
1695
                        av_init_packet(&opkt);
1696

    
1697
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1698
                            continue;
1699

    
1700
                        /* no reencoding needed : output the packet directly */
1701
                        /* force the input stream PTS */
1702

    
1703
                        avcodec_get_frame_defaults(&avframe);
1704
                        ost->st->codec->coded_frame= &avframe;
1705
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1706

    
1707
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1708
                            audio_size += data_size;
1709
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1710
                            video_size += data_size;
1711
                            ost->sync_opts++;
1712
                        }
1713

    
1714
                        opkt.stream_index= ost->index;
1715
                        if(pkt->pts != AV_NOPTS_VALUE)
1716
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1717
                        else
1718
                            opkt.pts= AV_NOPTS_VALUE;
1719

    
1720
                        if (pkt->dts == AV_NOPTS_VALUE)
1721
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1722
                        else
1723
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1724
                        opkt.dts -= ost_tb_start_time;
1725

    
1726
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1727
                        opkt.flags= pkt->flags;
1728

    
1729
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1730
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1731
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1732
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1733
                           ) {
1734
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1735
                                opkt.destruct= av_destruct_packet;
1736
                        } else {
1737
                            opkt.data = data_buf;
1738
                            opkt.size = data_size;
1739
                        }
1740

    
1741
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1742
                        ost->st->codec->frame_number++;
1743
                        ost->frame_number++;
1744
                        av_free_packet(&opkt);
1745
                    }
1746
                }
1747
            }
1748

    
1749
#if CONFIG_AVFILTER
1750
            frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1751
                              ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1752
            if(ist->picref)
1753
                avfilter_unref_buffer(ist->picref);
1754
        }
1755
#endif
1756
        av_free(buffer_to_free);
1757
        /* XXX: allocate the subtitles in the codec ? */
1758
        if (subtitle_to_free) {
1759
            avsubtitle_free(subtitle_to_free);
1760
            subtitle_to_free = NULL;
1761
        }
1762
    }
1763
 discard_packet:
1764
    if (pkt == NULL) {
1765
        /* EOF handling */
1766

    
1767
        for(i=0;i<nb_ostreams;i++) {
1768
            ost = ost_table[i];
1769
            if (ost->source_index == ist_index) {
1770
                AVCodecContext *enc= ost->st->codec;
1771
                os = output_files[ost->file_index];
1772

    
1773
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1774
                    continue;
1775
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1776
                    continue;
1777

    
1778
                if (ost->encoding_needed) {
1779
                    for(;;) {
1780
                        AVPacket pkt;
1781
                        int fifo_bytes;
1782
                        av_init_packet(&pkt);
1783
                        pkt.stream_index= ost->index;
1784

    
1785
                        switch(ost->st->codec->codec_type) {
1786
                        case AVMEDIA_TYPE_AUDIO:
1787
                            fifo_bytes = av_fifo_size(ost->fifo);
1788
                            ret = 0;
1789
                            /* encode any samples remaining in fifo */
1790
                            if (fifo_bytes > 0) {
1791
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1792
                                int fs_tmp = enc->frame_size;
1793

    
1794
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1795
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1796
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1797
                                } else { /* pad */
1798
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1799
                                    if (allocated_audio_buf_size < frame_bytes)
1800
                                        ffmpeg_exit(1);
1801
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1802
                                }
1803

    
1804
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1805
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1806
                                                          ost->st->time_base.num, enc->sample_rate);
1807
                                enc->frame_size = fs_tmp;
1808
                            }
1809
                            if(ret <= 0) {
1810
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1811
                            }
1812
                            if (ret < 0) {
1813
                                fprintf(stderr, "Audio encoding failed\n");
1814
                                ffmpeg_exit(1);
1815
                            }
1816
                            audio_size += ret;
1817
                            pkt.flags |= AV_PKT_FLAG_KEY;
1818
                            break;
1819
                        case AVMEDIA_TYPE_VIDEO:
1820
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1821
                            if (ret < 0) {
1822
                                fprintf(stderr, "Video encoding failed\n");
1823
                                ffmpeg_exit(1);
1824
                            }
1825
                            video_size += ret;
1826
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1827
                                pkt.flags |= AV_PKT_FLAG_KEY;
1828
                            if (ost->logfile && enc->stats_out) {
1829
                                fprintf(ost->logfile, "%s", enc->stats_out);
1830
                            }
1831
                            break;
1832
                        default:
1833
                            ret=-1;
1834
                        }
1835

    
1836
                        if(ret<=0)
1837
                            break;
1838
                        pkt.data= bit_buffer;
1839
                        pkt.size= ret;
1840
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1841
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1842
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1843
                    }
1844
                }
1845
            }
1846
        }
1847
    }
1848

    
1849
    return 0;
1850
 fail_decode:
1851
    return -1;
1852
}
1853

    
1854
static void print_sdp(AVFormatContext **avc, int n)
1855
{
1856
    char sdp[2048];
1857

    
1858
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1859
    printf("SDP:\n%s\n", sdp);
1860
    fflush(stdout);
1861
}
1862

    
1863
static int copy_chapters(int infile, int outfile)
1864
{
1865
    AVFormatContext *is = input_files[infile];
1866
    AVFormatContext *os = output_files[outfile];
1867
    int i;
1868

    
1869
    for (i = 0; i < is->nb_chapters; i++) {
1870
        AVChapter *in_ch = is->chapters[i], *out_ch;
1871
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1872
                                      AV_TIME_BASE_Q, in_ch->time_base);
1873
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1874
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1875

    
1876

    
1877
        if (in_ch->end < ts_off)
1878
            continue;
1879
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1880
            break;
1881

    
1882
        out_ch = av_mallocz(sizeof(AVChapter));
1883
        if (!out_ch)
1884
            return AVERROR(ENOMEM);
1885

    
1886
        out_ch->id        = in_ch->id;
1887
        out_ch->time_base = in_ch->time_base;
1888
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1889
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1890

    
1891
        if (metadata_chapters_autocopy)
1892
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1893

    
1894
        os->nb_chapters++;
1895
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1896
        if (!os->chapters)
1897
            return AVERROR(ENOMEM);
1898
        os->chapters[os->nb_chapters - 1] = out_ch;
1899
    }
1900
    return 0;
1901
}
1902

    
1903
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1904
                                    AVCodecContext *avctx)
1905
{
1906
    char *p;
1907
    int n = 1, i;
1908
    int64_t t;
1909

    
1910
    for (p = kf; *p; p++)
1911
        if (*p == ',')
1912
            n++;
1913
    ost->forced_kf_count = n;
1914
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1915
    if (!ost->forced_kf_pts) {
1916
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1917
        ffmpeg_exit(1);
1918
    }
1919
    for (i = 0; i < n; i++) {
1920
        p = i ? strchr(p, ',') + 1 : kf;
1921
        t = parse_time_or_die("force_key_frames", p, 1);
1922
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1923
    }
1924
}
1925

    
1926
/*
1927
 * The following code is the main loop of the file converter
1928
 */
1929
static int transcode(AVFormatContext **output_files,
1930
                     int nb_output_files,
1931
                     AVFormatContext **input_files,
1932
                     int nb_input_files,
1933
                     AVStreamMap *stream_maps, int nb_stream_maps)
1934
{
1935
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1936
    AVFormatContext *is, *os;
1937
    AVCodecContext *codec, *icodec;
1938
    AVOutputStream *ost, **ost_table = NULL;
1939
    AVInputStream *ist, **ist_table = NULL;
1940
    AVInputFile *file_table;
1941
    char error[1024];
1942
    int key;
1943
    int want_sdp = 1;
1944
    uint8_t no_packet[MAX_FILES]={0};
1945
    int no_packet_count=0;
1946

    
1947
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1948
    if (!file_table)
1949
        goto fail;
1950

    
1951
    /* input stream init */
1952
    j = 0;
1953
    for(i=0;i<nb_input_files;i++) {
1954
        is = input_files[i];
1955
        file_table[i].ist_index = j;
1956
        file_table[i].nb_streams = is->nb_streams;
1957
        j += is->nb_streams;
1958
    }
1959
    nb_istreams = j;
1960

    
1961
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1962
    if (!ist_table)
1963
        goto fail;
1964

    
1965
    for(i=0;i<nb_istreams;i++) {
1966
        ist = av_mallocz(sizeof(AVInputStream));
1967
        if (!ist)
1968
            goto fail;
1969
        ist_table[i] = ist;
1970
    }
1971
    j = 0;
1972
    for(i=0;i<nb_input_files;i++) {
1973
        is = input_files[i];
1974
        for(k=0;k<is->nb_streams;k++) {
1975
            ist = ist_table[j++];
1976
            ist->st = is->streams[k];
1977
            ist->file_index = i;
1978
            ist->index = k;
1979
            ist->discard = 1; /* the stream is discarded by default
1980
                                 (changed later) */
1981

    
1982
            if (rate_emu) {
1983
                ist->start = av_gettime();
1984
            }
1985
        }
1986
    }
1987

    
1988
    /* output stream init */
1989
    nb_ostreams = 0;
1990
    for(i=0;i<nb_output_files;i++) {
1991
        os = output_files[i];
1992
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1993
            dump_format(output_files[i], i, output_files[i]->filename, 1);
1994
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1995
            ret = AVERROR(EINVAL);
1996
            goto fail;
1997
        }
1998
        nb_ostreams += os->nb_streams;
1999
    }
2000
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2001
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
2002
        ret = AVERROR(EINVAL);
2003
        goto fail;
2004
    }
2005

    
2006
    /* Sanity check the mapping args -- do the input files & streams exist? */
2007
    for(i=0;i<nb_stream_maps;i++) {
2008
        int fi = stream_maps[i].file_index;
2009
        int si = stream_maps[i].stream_index;
2010

    
2011
        if (fi < 0 || fi > nb_input_files - 1 ||
2012
            si < 0 || si > file_table[fi].nb_streams - 1) {
2013
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2014
            ret = AVERROR(EINVAL);
2015
            goto fail;
2016
        }
2017
        fi = stream_maps[i].sync_file_index;
2018
        si = stream_maps[i].sync_stream_index;
2019
        if (fi < 0 || fi > nb_input_files - 1 ||
2020
            si < 0 || si > file_table[fi].nb_streams - 1) {
2021
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2022
            ret = AVERROR(EINVAL);
2023
            goto fail;
2024
        }
2025
    }
2026

    
2027
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2028
    if (!ost_table)
2029
        goto fail;
2030
    n = 0;
2031
    for(k=0;k<nb_output_files;k++) {
2032
        os = output_files[k];
2033
        for(i=0;i<os->nb_streams;i++,n++) {
2034
            int found;
2035
            ost = ost_table[n] = output_streams_for_file[k][i];
2036
            ost->st = os->streams[i];
2037
            if (nb_stream_maps > 0) {
2038
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2039
                    stream_maps[n].stream_index;
2040

    
2041
                /* Sanity check that the stream types match */
2042
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2043
                    int i= ost->file_index;
2044
                    dump_format(output_files[i], i, output_files[i]->filename, 1);
2045
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2046
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2047
                        ost->file_index, ost->index);
2048
                    ffmpeg_exit(1);
2049
                }
2050

    
2051
            } else {
2052
                int best_nb_frames=-1;
2053
                /* get corresponding input stream index : we select the first one with the right type */
2054
                found = 0;
2055
                for(j=0;j<nb_istreams;j++) {
2056
                    int skip=0;
2057
                    ist = ist_table[j];
2058
                    if(opt_programid){
2059
                        int pi,si;
2060
                        AVFormatContext *f= input_files[ ist->file_index ];
2061
                        skip=1;
2062
                        for(pi=0; pi<f->nb_programs; pi++){
2063
                            AVProgram *p= f->programs[pi];
2064
                            if(p->id == opt_programid)
2065
                                for(si=0; si<p->nb_stream_indexes; si++){
2066
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2067
                                        skip=0;
2068
                                }
2069
                        }
2070
                    }
2071
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2072
                        ist->st->codec->codec_type == ost->st->codec->codec_type) {
2073
                        if(best_nb_frames < ist->st->codec_info_nb_frames){
2074
                            best_nb_frames= ist->st->codec_info_nb_frames;
2075
                            ost->source_index = j;
2076
                            found = 1;
2077
                        }
2078
                    }
2079
                }
2080

    
2081
                if (!found) {
2082
                    if(! opt_programid) {
2083
                        /* try again and reuse existing stream */
2084
                        for(j=0;j<nb_istreams;j++) {
2085
                            ist = ist_table[j];
2086
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2087
                                && ist->st->discard != AVDISCARD_ALL) {
2088
                                ost->source_index = j;
2089
                                found = 1;
2090
                            }
2091
                        }
2092
                    }
2093
                    if (!found) {
2094
                        int i= ost->file_index;
2095
                        dump_format(output_files[i], i, output_files[i]->filename, 1);
2096
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2097
                                ost->file_index, ost->index);
2098
                        ffmpeg_exit(1);
2099
                    }
2100
                }
2101
            }
2102
            ist = ist_table[ost->source_index];
2103
            ist->discard = 0;
2104
            ost->sync_ist = (nb_stream_maps > 0) ?
2105
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2106
                         stream_maps[n].sync_stream_index] : ist;
2107
        }
2108
    }
2109

    
2110
    /* for each output stream, we compute the right encoding parameters */
2111
    for(i=0;i<nb_ostreams;i++) {
2112
        ost = ost_table[i];
2113
        os = output_files[ost->file_index];
2114
        ist = ist_table[ost->source_index];
2115

    
2116
        codec = ost->st->codec;
2117
        icodec = ist->st->codec;
2118

    
2119
        if (metadata_streams_autocopy)
2120
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2121
                             AV_METADATA_DONT_OVERWRITE);
2122

    
2123
        ost->st->disposition = ist->st->disposition;
2124
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2125
        codec->chroma_sample_location = icodec->chroma_sample_location;
2126

    
2127
        if (ost->st->stream_copy) {
2128
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2129

    
2130
            if (extra_size > INT_MAX)
2131
                goto fail;
2132

    
2133
            /* if stream_copy is selected, no need to decode or encode */
2134
            codec->codec_id = icodec->codec_id;
2135
            codec->codec_type = icodec->codec_type;
2136

    
2137
            if(!codec->codec_tag){
2138
                if(   !os->oformat->codec_tag
2139
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2140
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2141
                    codec->codec_tag = icodec->codec_tag;
2142
            }
2143

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

    
2233
                    ost->original_height = icodec->height;
2234
                    ost->original_width  = icodec->width;
2235
#endif
2236
                    codec->bits_per_raw_sample= 0;
2237
                }
2238
                ost->resample_height = icodec->height;
2239
                ost->resample_width  = icodec->width;
2240
                ost->resample_pix_fmt= icodec->pix_fmt;
2241
                ost->encoding_needed = 1;
2242
                ist->decoding_needed = 1;
2243

    
2244
#if CONFIG_AVFILTER
2245
                if (configure_filters(ist, ost)) {
2246
                    fprintf(stderr, "Error opening filters!\n");
2247
                    exit(1);
2248
                }
2249
#endif
2250
                break;
2251
            case AVMEDIA_TYPE_SUBTITLE:
2252
                ost->encoding_needed = 1;
2253
                ist->decoding_needed = 1;
2254
                break;
2255
            default:
2256
                abort();
2257
                break;
2258
            }
2259
            /* two pass mode */
2260
            if (ost->encoding_needed &&
2261
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2262
                char logfilename[1024];
2263
                FILE *f;
2264

    
2265
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2266
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2267
                         i);
2268
                if (codec->flags & CODEC_FLAG_PASS1) {
2269
                    f = fopen(logfilename, "wb");
2270
                    if (!f) {
2271
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2272
                        ffmpeg_exit(1);
2273
                    }
2274
                    ost->logfile = f;
2275
                } else {
2276
                    char  *logbuffer;
2277
                    size_t logbuffer_size;
2278
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2279
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2280
                        ffmpeg_exit(1);
2281
                    }
2282
                    codec->stats_in = logbuffer;
2283
                }
2284
            }
2285
        }
2286
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2287
            int size= codec->width * codec->height;
2288
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2289
        }
2290
    }
2291

    
2292
    if (!bit_buffer)
2293
        bit_buffer = av_malloc(bit_buffer_size);
2294
    if (!bit_buffer) {
2295
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2296
                bit_buffer_size);
2297
        ret = AVERROR(ENOMEM);
2298
        goto fail;
2299
    }
2300

    
2301
    /* open each encoder */
2302
    for(i=0;i<nb_ostreams;i++) {
2303
        ost = ost_table[i];
2304
        if (ost->encoding_needed) {
2305
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2306
            AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2307
            if (!codec)
2308
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2309
            if (!codec) {
2310
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2311
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2312
                ret = AVERROR(EINVAL);
2313
                goto dump_format;
2314
            }
2315
            if (dec->subtitle_header) {
2316
                ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2317
                if (!ost->st->codec->subtitle_header) {
2318
                    ret = AVERROR(ENOMEM);
2319
                    goto dump_format;
2320
                }
2321
                memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2322
                ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2323
            }
2324
            if (avcodec_open(ost->st->codec, codec) < 0) {
2325
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2326
                        ost->file_index, ost->index);
2327
                ret = AVERROR(EINVAL);
2328
                goto dump_format;
2329
            }
2330
            extra_size += ost->st->codec->extradata_size;
2331
        }
2332
    }
2333

    
2334
    /* open each decoder */
2335
    for(i=0;i<nb_istreams;i++) {
2336
        ist = ist_table[i];
2337
        if (ist->decoding_needed) {
2338
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2339
            if (!codec)
2340
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2341
            if (!codec) {
2342
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2343
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2344
                ret = AVERROR(EINVAL);
2345
                goto dump_format;
2346
            }
2347
            if (avcodec_open(ist->st->codec, codec) < 0) {
2348
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2349
                        ist->file_index, ist->index);
2350
                ret = AVERROR(EINVAL);
2351
                goto dump_format;
2352
            }
2353
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2354
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2355
        }
2356
    }
2357

    
2358
    /* init pts */
2359
    for(i=0;i<nb_istreams;i++) {
2360
        AVStream *st;
2361
        ist = ist_table[i];
2362
        st= ist->st;
2363
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2364
        ist->next_pts = AV_NOPTS_VALUE;
2365
        init_pts_correction(&ist->pts_ctx);
2366
        ist->is_start = 1;
2367
    }
2368

    
2369
    /* set meta data information from input file if required */
2370
    for (i=0;i<nb_meta_data_maps;i++) {
2371
        AVFormatContext *files[2];
2372
        AVMetadata      **meta[2];
2373
        int j;
2374

    
2375
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2376
        if ((index) < 0 || (index) >= (nb_elems)) {\
2377
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2378
                     (desc), (index));\
2379
            ret = AVERROR(EINVAL);\
2380
            goto dump_format;\
2381
        }
2382

    
2383
        int out_file_index = meta_data_maps[i][0].file;
2384
        int in_file_index = meta_data_maps[i][1].file;
2385
        if (in_file_index < 0 || out_file_index < 0)
2386
            continue;
2387
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2388
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2389

    
2390
        files[0] = output_files[out_file_index];
2391
        files[1] = input_files[in_file_index];
2392

    
2393
        for (j = 0; j < 2; j++) {
2394
            AVMetaDataMap *map = &meta_data_maps[i][j];
2395

    
2396
            switch (map->type) {
2397
            case 'g':
2398
                meta[j] = &files[j]->metadata;
2399
                break;
2400
            case 's':
2401
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2402
                meta[j] = &files[j]->streams[map->index]->metadata;
2403
                break;
2404
            case 'c':
2405
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2406
                meta[j] = &files[j]->chapters[map->index]->metadata;
2407
                break;
2408
            case 'p':
2409
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2410
                meta[j] = &files[j]->programs[map->index]->metadata;
2411
                break;
2412
            }
2413
        }
2414

    
2415
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2416
    }
2417

    
2418
    /* copy global metadata by default */
2419
    if (metadata_global_autocopy) {
2420

    
2421
        for (i = 0; i < nb_output_files; i++)
2422
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2423
                             AV_METADATA_DONT_OVERWRITE);
2424
    }
2425

    
2426
    /* copy chapters according to chapter maps */
2427
    for (i = 0; i < nb_chapter_maps; i++) {
2428
        int infile  = chapter_maps[i].in_file;
2429
        int outfile = chapter_maps[i].out_file;
2430

    
2431
        if (infile < 0 || outfile < 0)
2432
            continue;
2433
        if (infile >= nb_input_files) {
2434
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2435
            ret = AVERROR(EINVAL);
2436
            goto dump_format;
2437
        }
2438
        if (outfile >= nb_output_files) {
2439
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2440
            ret = AVERROR(EINVAL);
2441
            goto dump_format;
2442
        }
2443
        copy_chapters(infile, outfile);
2444
    }
2445

    
2446
    /* copy chapters from the first input file that has them*/
2447
    if (!nb_chapter_maps)
2448
        for (i = 0; i < nb_input_files; i++) {
2449
            if (!input_files[i]->nb_chapters)
2450
                continue;
2451

    
2452
            for (j = 0; j < nb_output_files; j++)
2453
                if ((ret = copy_chapters(i, j)) < 0)
2454
                    goto dump_format;
2455
            break;
2456
        }
2457

    
2458
    /* open files and write file headers */
2459
    for(i=0;i<nb_output_files;i++) {
2460
        os = output_files[i];
2461
        if (av_write_header(os) < 0) {
2462
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2463
            ret = AVERROR(EINVAL);
2464
            goto dump_format;
2465
        }
2466
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2467
            want_sdp = 0;
2468
        }
2469
    }
2470

    
2471
 dump_format:
2472
    /* dump the file output parameters - cannot be done before in case
2473
       of stream copy */
2474
    for(i=0;i<nb_output_files;i++) {
2475
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2476
    }
2477

    
2478
    /* dump the stream mapping */
2479
    if (verbose >= 0) {
2480
        fprintf(stderr, "Stream mapping:\n");
2481
        for(i=0;i<nb_ostreams;i++) {
2482
            ost = ost_table[i];
2483
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2484
                    ist_table[ost->source_index]->file_index,
2485
                    ist_table[ost->source_index]->index,
2486
                    ost->file_index,
2487
                    ost->index);
2488
            if (ost->sync_ist != ist_table[ost->source_index])
2489
                fprintf(stderr, " [sync #%d.%d]",
2490
                        ost->sync_ist->file_index,
2491
                        ost->sync_ist->index);
2492
            fprintf(stderr, "\n");
2493
        }
2494
    }
2495

    
2496
    if (ret) {
2497
        fprintf(stderr, "%s\n", error);
2498
        goto fail;
2499
    }
2500

    
2501
    if (want_sdp) {
2502
        print_sdp(output_files, nb_output_files);
2503
    }
2504

    
2505
    if (!using_stdin && verbose >= 0) {
2506
        fprintf(stderr, "Press [q] to stop encoding\n");
2507
        url_set_interrupt_cb(decode_interrupt_cb);
2508
    }
2509
    term_init();
2510

    
2511
    timer_start = av_gettime();
2512

    
2513
    for(; received_sigterm == 0;) {
2514
        int file_index, ist_index;
2515
        AVPacket pkt;
2516
        double ipts_min;
2517
        double opts_min;
2518

    
2519
    redo:
2520
        ipts_min= 1e100;
2521
        opts_min= 1e100;
2522
        /* if 'q' pressed, exits */
2523
        if (!using_stdin) {
2524
            if (q_pressed)
2525
                break;
2526
            /* read_key() returns 0 on EOF */
2527
            key = read_key();
2528
            if (key == 'q')
2529
                break;
2530
        }
2531

    
2532
        /* select the stream that we must read now by looking at the
2533
           smallest output pts */
2534
        file_index = -1;
2535
        for(i=0;i<nb_ostreams;i++) {
2536
            double ipts, opts;
2537
            ost = ost_table[i];
2538
            os = output_files[ost->file_index];
2539
            ist = ist_table[ost->source_index];
2540
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2541
                continue;
2542
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2543
            ipts = (double)ist->pts;
2544
            if (!file_table[ist->file_index].eof_reached){
2545
                if(ipts < ipts_min) {
2546
                    ipts_min = ipts;
2547
                    if(input_sync ) file_index = ist->file_index;
2548
                }
2549
                if(opts < opts_min) {
2550
                    opts_min = opts;
2551
                    if(!input_sync) file_index = ist->file_index;
2552
                }
2553
            }
2554
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2555
                file_index= -1;
2556
                break;
2557
            }
2558
        }
2559
        /* if none, if is finished */
2560
        if (file_index < 0) {
2561
            if(no_packet_count){
2562
                no_packet_count=0;
2563
                memset(no_packet, 0, sizeof(no_packet));
2564
                usleep(10000);
2565
                continue;
2566
            }
2567
            break;
2568
        }
2569

    
2570
        /* finish if limit size exhausted */
2571
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2572
            break;
2573

    
2574
        /* read a frame from it and output it in the fifo */
2575
        is = input_files[file_index];
2576
        ret= av_read_frame(is, &pkt);
2577
        if(ret == AVERROR(EAGAIN)){
2578
            no_packet[file_index]=1;
2579
            no_packet_count++;
2580
            continue;
2581
        }
2582
        if (ret < 0) {
2583
            file_table[file_index].eof_reached = 1;
2584
            if (opt_shortest)
2585
                break;
2586
            else
2587
                continue;
2588
        }
2589

    
2590
        no_packet_count=0;
2591
        memset(no_packet, 0, sizeof(no_packet));
2592

    
2593
        if (do_pkt_dump) {
2594
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2595
        }
2596
        /* the following test is needed in case new streams appear
2597
           dynamically in stream : we ignore them */
2598
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2599
            goto discard_packet;
2600
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2601
        ist = ist_table[ist_index];
2602
        if (ist->discard)
2603
            goto discard_packet;
2604

    
2605
        if (pkt.dts != AV_NOPTS_VALUE)
2606
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2607
        if (pkt.pts != AV_NOPTS_VALUE)
2608
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2609

    
2610
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2611
            && input_files_ts_scale[file_index][pkt.stream_index]){
2612
            if(pkt.pts != AV_NOPTS_VALUE)
2613
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2614
            if(pkt.dts != AV_NOPTS_VALUE)
2615
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2616
        }
2617

    
2618
//        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);
2619
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2620
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2621
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2622
            int64_t delta= pkt_dts - ist->next_pts;
2623
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2624
                input_files_ts_offset[ist->file_index]-= delta;
2625
                if (verbose > 2)
2626
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2627
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2628
                if(pkt.pts != AV_NOPTS_VALUE)
2629
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2630
            }
2631
        }
2632

    
2633
        /* finish if recording time exhausted */
2634
        if (recording_time != INT64_MAX &&
2635
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2636
            ist->is_past_recording_time = 1;
2637
            goto discard_packet;
2638
        }
2639

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

    
2643
            if (verbose >= 0)
2644
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2645
                        ist->file_index, ist->index);
2646
            if (exit_on_error)
2647
                ffmpeg_exit(1);
2648
            av_free_packet(&pkt);
2649
            goto redo;
2650
        }
2651

    
2652
    discard_packet:
2653
        av_free_packet(&pkt);
2654

    
2655
        /* dump report by using the output first video and audio streams */
2656
        print_report(output_files, ost_table, nb_ostreams, 0);
2657
    }
2658

    
2659
    /* at the end of stream, we must flush the decoder buffers */
2660
    for(i=0;i<nb_istreams;i++) {
2661
        ist = ist_table[i];
2662
        if (ist->decoding_needed) {
2663
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2664
        }
2665
    }
2666

    
2667
    term_exit();
2668

    
2669
    /* write the trailer if needed and close file */
2670
    for(i=0;i<nb_output_files;i++) {
2671
        os = output_files[i];
2672
        av_write_trailer(os);
2673
    }
2674

    
2675
    /* dump report by using the first video and audio streams */
2676
    print_report(output_files, ost_table, nb_ostreams, 1);
2677

    
2678
    /* close each encoder */
2679
    for(i=0;i<nb_ostreams;i++) {
2680
        ost = ost_table[i];
2681
        if (ost->encoding_needed) {
2682
            av_freep(&ost->st->codec->stats_in);
2683
            avcodec_close(ost->st->codec);
2684
        }
2685
    }
2686

    
2687
    /* close each decoder */
2688
    for(i=0;i<nb_istreams;i++) {
2689
        ist = ist_table[i];
2690
        if (ist->decoding_needed) {
2691
            avcodec_close(ist->st->codec);
2692
        }
2693
    }
2694
#if CONFIG_AVFILTER
2695
    if (graph) {
2696
        avfilter_graph_free(graph);
2697
        av_freep(&graph);
2698
    }
2699
#endif
2700

    
2701
    /* finished ! */
2702
    ret = 0;
2703

    
2704
 fail:
2705
    av_freep(&bit_buffer);
2706
    av_free(file_table);
2707

    
2708
    if (ist_table) {
2709
        for(i=0;i<nb_istreams;i++) {
2710
            ist = ist_table[i];
2711
            av_free(ist);
2712
        }
2713
        av_free(ist_table);
2714
    }
2715
    if (ost_table) {
2716
        for(i=0;i<nb_ostreams;i++) {
2717
            ost = ost_table[i];
2718
            if (ost) {
2719
                if (ost->st->stream_copy)
2720
                    av_freep(&ost->st->codec->extradata);
2721
                if (ost->logfile) {
2722
                    fclose(ost->logfile);
2723
                    ost->logfile = NULL;
2724
                }
2725
                av_fifo_free(ost->fifo); /* works even if fifo is not
2726
                                             initialized but set to zero */
2727
                av_freep(&ost->st->codec->subtitle_header);
2728
                av_free(ost->pict_tmp.data[0]);
2729
                av_free(ost->forced_kf_pts);
2730
                if (ost->video_resample)
2731
                    sws_freeContext(ost->img_resample_ctx);
2732
                if (ost->resample)
2733
                    audio_resample_close(ost->resample);
2734
                if (ost->reformat_ctx)
2735
                    av_audio_convert_free(ost->reformat_ctx);
2736
                av_free(ost);
2737
            }
2738
        }
2739
        av_free(ost_table);
2740
    }
2741
    return ret;
2742
}
2743

    
2744
static void opt_format(const char *arg)
2745
{
2746
    last_asked_format = arg;
2747
}
2748

    
2749
static void opt_video_rc_override_string(const char *arg)
2750
{
2751
    video_rc_override_string = arg;
2752
}
2753

    
2754
static int opt_me_threshold(const char *opt, const char *arg)
2755
{
2756
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2757
    return 0;
2758
}
2759

    
2760
static int opt_verbose(const char *opt, const char *arg)
2761
{
2762
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2763
    return 0;
2764
}
2765

    
2766
static int opt_frame_rate(const char *opt, const char *arg)
2767
{
2768
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2769
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2770
        ffmpeg_exit(1);
2771
    }
2772
    return 0;
2773
}
2774

    
2775
static int opt_bitrate(const char *opt, const char *arg)
2776
{
2777
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2778

    
2779
    opt_default(opt, arg);
2780

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

    
2784
    return 0;
2785
}
2786

    
2787
static int opt_frame_crop(const char *opt, const char *arg)
2788
{
2789
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2790
    return AVERROR(EINVAL);
2791
}
2792

    
2793
static void opt_frame_size(const char *arg)
2794
{
2795
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2796
        fprintf(stderr, "Incorrect frame size\n");
2797
        ffmpeg_exit(1);
2798
    }
2799
}
2800

    
2801
static int opt_pad(const char *opt, const char *arg) {
2802
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2803
    return -1;
2804
}
2805

    
2806
static void opt_frame_pix_fmt(const char *arg)
2807
{
2808
    if (strcmp(arg, "list")) {
2809
        frame_pix_fmt = av_get_pix_fmt(arg);
2810
        if (frame_pix_fmt == PIX_FMT_NONE) {
2811
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2812
            ffmpeg_exit(1);
2813
        }
2814
    } else {
2815
        show_pix_fmts();
2816
        ffmpeg_exit(0);
2817
    }
2818
}
2819

    
2820
static void opt_frame_aspect_ratio(const char *arg)
2821
{
2822
    int x = 0, y = 0;
2823
    double ar = 0;
2824
    const char *p;
2825
    char *end;
2826

    
2827
    p = strchr(arg, ':');
2828
    if (p) {
2829
        x = strtol(arg, &end, 10);
2830
        if (end == p)
2831
            y = strtol(end+1, &end, 10);
2832
        if (x > 0 && y > 0)
2833
            ar = (double)x / (double)y;
2834
    } else
2835
        ar = strtod(arg, NULL);
2836

    
2837
    if (!ar) {
2838
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2839
        ffmpeg_exit(1);
2840
    }
2841
    frame_aspect_ratio = ar;
2842
}
2843

    
2844
static int opt_metadata(const char *opt, const char *arg)
2845
{
2846
    char *mid= strchr(arg, '=');
2847

    
2848
    if(!mid){
2849
        fprintf(stderr, "Missing =\n");
2850
        ffmpeg_exit(1);
2851
    }
2852
    *mid++= 0;
2853

    
2854
    av_metadata_set2(&metadata, arg, mid, 0);
2855

    
2856
    return 0;
2857
}
2858

    
2859
static void opt_qscale(const char *arg)
2860
{
2861
    video_qscale = atof(arg);
2862
    if (video_qscale <= 0 ||
2863
        video_qscale > 255) {
2864
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2865
        ffmpeg_exit(1);
2866
    }
2867
}
2868

    
2869
static void opt_top_field_first(const char *arg)
2870
{
2871
    top_field_first= atoi(arg);
2872
}
2873

    
2874
static int opt_thread_count(const char *opt, const char *arg)
2875
{
2876
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2877
#if !HAVE_THREADS
2878
    if (verbose >= 0)
2879
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2880
#endif
2881
    return 0;
2882
}
2883

    
2884
static void opt_audio_sample_fmt(const char *arg)
2885
{
2886
    if (strcmp(arg, "list")) {
2887
        audio_sample_fmt = av_get_sample_fmt(arg);
2888
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2889
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2890
            ffmpeg_exit(1);
2891
        }
2892
    } else {
2893
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2894
        ffmpeg_exit(0);
2895
    }
2896
}
2897

    
2898
static int opt_audio_rate(const char *opt, const char *arg)
2899
{
2900
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2901
    return 0;
2902
}
2903

    
2904
static int opt_audio_channels(const char *opt, const char *arg)
2905
{
2906
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2907
    return 0;
2908
}
2909

    
2910
static void opt_video_channel(const char *arg)
2911
{
2912
    video_channel = strtol(arg, NULL, 0);
2913
}
2914

    
2915
static void opt_video_standard(const char *arg)
2916
{
2917
    video_standard = av_strdup(arg);
2918
}
2919

    
2920
static void opt_codec(int *pstream_copy, char **pcodec_name,
2921
                      int codec_type, const char *arg)
2922
{
2923
    av_freep(pcodec_name);
2924
    if (!strcmp(arg, "copy")) {
2925
        *pstream_copy = 1;
2926
    } else {
2927
        *pcodec_name = av_strdup(arg);
2928
    }
2929
}
2930

    
2931
static void opt_audio_codec(const char *arg)
2932
{
2933
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2934
}
2935

    
2936
static void opt_video_codec(const char *arg)
2937
{
2938
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2939
}
2940

    
2941
static void opt_subtitle_codec(const char *arg)
2942
{
2943
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2944
}
2945

    
2946
static int opt_codec_tag(const char *opt, const char *arg)
2947
{
2948
    char *tail;
2949
    uint32_t *codec_tag;
2950

    
2951
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2952
                !strcmp(opt, "vtag") ? &video_codec_tag :
2953
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2954
    if (!codec_tag)
2955
        return -1;
2956

    
2957
    *codec_tag = strtol(arg, &tail, 0);
2958
    if (!tail || *tail)
2959
        *codec_tag = AV_RL32(arg);
2960

    
2961
    return 0;
2962
}
2963

    
2964
static void opt_map(const char *arg)
2965
{
2966
    AVStreamMap *m;
2967
    char *p;
2968

    
2969
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2970
    m = &stream_maps[nb_stream_maps-1];
2971

    
2972
    m->file_index = strtol(arg, &p, 0);
2973
    if (*p)
2974
        p++;
2975

    
2976
    m->stream_index = strtol(p, &p, 0);
2977
    if (*p) {
2978
        p++;
2979
        m->sync_file_index = strtol(p, &p, 0);
2980
        if (*p)
2981
            p++;
2982
        m->sync_stream_index = strtol(p, &p, 0);
2983
    } else {
2984
        m->sync_file_index = m->file_index;
2985
        m->sync_stream_index = m->stream_index;
2986
    }
2987
}
2988

    
2989
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2990
{
2991
    *endptr = arg;
2992
    if (*arg == ',') {
2993
        *type = *(++arg);
2994
        switch (*arg) {
2995
        case 'g':
2996
            break;
2997
        case 's':
2998
        case 'c':
2999
        case 'p':
3000
            *index = strtol(++arg, endptr, 0);
3001
            break;
3002
        default:
3003
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3004
            ffmpeg_exit(1);
3005
        }
3006
    } else
3007
        *type = 'g';
3008
}
3009

    
3010
static void opt_map_meta_data(const char *arg)
3011
{
3012
    AVMetaDataMap *m, *m1;
3013
    char *p;
3014

    
3015
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3016
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3017

    
3018
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3019
    m->file = strtol(arg, &p, 0);
3020
    parse_meta_type(p, &m->type, &m->index, &p);
3021
    if (*p)
3022
        p++;
3023

    
3024
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3025
    m1->file = strtol(p, &p, 0);
3026
    parse_meta_type(p, &m1->type, &m1->index, &p);
3027

    
3028
    if (m->type == 'g' || m1->type == 'g')
3029
        metadata_global_autocopy = 0;
3030
    if (m->type == 's' || m1->type == 's')
3031
        metadata_streams_autocopy = 0;
3032
    if (m->type == 'c' || m1->type == 'c')
3033
        metadata_chapters_autocopy = 0;
3034
}
3035

    
3036
static void opt_map_chapters(const char *arg)
3037
{
3038
    AVChapterMap *c;
3039
    char *p;
3040

    
3041
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3042
                              nb_chapter_maps + 1);
3043
    c = &chapter_maps[nb_chapter_maps - 1];
3044
    c->out_file = strtol(arg, &p, 0);
3045
    if (*p)
3046
        p++;
3047

    
3048
    c->in_file = strtol(p, &p, 0);
3049
}
3050

    
3051
static void opt_input_ts_scale(const char *arg)
3052
{
3053
    unsigned int stream;
3054
    double scale;
3055
    char *p;
3056

    
3057
    stream = strtol(arg, &p, 0);
3058
    if (*p)
3059
        p++;
3060
    scale= strtod(p, &p);
3061

    
3062
    if(stream >= MAX_STREAMS)
3063
        ffmpeg_exit(1);
3064

    
3065
    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);
3066
    input_files_ts_scale[nb_input_files][stream]= scale;
3067
}
3068

    
3069
static int opt_recording_time(const char *opt, const char *arg)
3070
{
3071
    recording_time = parse_time_or_die(opt, arg, 1);
3072
    return 0;
3073
}
3074

    
3075
static int opt_start_time(const char *opt, const char *arg)
3076
{
3077
    start_time = parse_time_or_die(opt, arg, 1);
3078
    return 0;
3079
}
3080

    
3081
static int opt_recording_timestamp(const char *opt, const char *arg)
3082
{
3083
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3084
    return 0;
3085
}
3086

    
3087
static int opt_input_ts_offset(const char *opt, const char *arg)
3088
{
3089
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3090
    return 0;
3091
}
3092

    
3093
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3094
{
3095
    const char *codec_string = encoder ? "encoder" : "decoder";
3096
    AVCodec *codec;
3097

    
3098
    if(!name)
3099
        return CODEC_ID_NONE;
3100
    codec = encoder ?
3101
        avcodec_find_encoder_by_name(name) :
3102
        avcodec_find_decoder_by_name(name);
3103
    if(!codec) {
3104
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3105
        ffmpeg_exit(1);
3106
    }
3107
    if(codec->type != type) {
3108
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3109
        ffmpeg_exit(1);
3110
    }
3111
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3112
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3113
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3114
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3115
                codec_string, codec->name);
3116
        codec = encoder ?
3117
            avcodec_find_encoder(codec->id) :
3118
            avcodec_find_decoder(codec->id);
3119
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3120
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3121
                    codec_string, codec->name);
3122
        ffmpeg_exit(1);
3123
    }
3124
    return codec->id;
3125
}
3126

    
3127
static void opt_input_file(const char *filename)
3128
{
3129
    AVFormatContext *ic;
3130
    AVFormatParameters params, *ap = &params;
3131
    AVInputFormat *file_iformat = NULL;
3132
    int err, i, ret, rfps, rfps_base;
3133
    int64_t timestamp;
3134

    
3135
    if (last_asked_format) {
3136
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3137
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3138
            ffmpeg_exit(1);
3139
        }
3140
        last_asked_format = NULL;
3141
    }
3142

    
3143
    if (!strcmp(filename, "-"))
3144
        filename = "pipe:";
3145

    
3146
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3147
                    !strcmp(filename, "/dev/stdin");
3148

    
3149
    /* get default parameters from command line */
3150
    ic = avformat_alloc_context();
3151
    if (!ic) {
3152
        print_error(filename, AVERROR(ENOMEM));
3153
        ffmpeg_exit(1);
3154
    }
3155

    
3156
    memset(ap, 0, sizeof(*ap));
3157
    ap->prealloced_context = 1;
3158
    ap->sample_rate = audio_sample_rate;
3159
    ap->channels = audio_channels;
3160
    ap->time_base.den = frame_rate.num;
3161
    ap->time_base.num = frame_rate.den;
3162
    ap->width = frame_width;
3163
    ap->height = frame_height;
3164
    ap->pix_fmt = frame_pix_fmt;
3165
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3166
    ap->channel = video_channel;
3167
    ap->standard = video_standard;
3168

    
3169
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3170

    
3171
    ic->video_codec_id   =
3172
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3173
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3174
    ic->audio_codec_id   =
3175
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3176
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3177
    ic->subtitle_codec_id=
3178
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3179
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3180
    ic->flags |= AVFMT_FLAG_NONBLOCK;
3181

    
3182
    /* open the input file with generic libav function */
3183
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3184
    if (err < 0) {
3185
        print_error(filename, err);
3186
        ffmpeg_exit(1);
3187
    }
3188
    if(opt_programid) {
3189
        int i, j;
3190
        int found=0;
3191
        for(i=0; i<ic->nb_streams; i++){
3192
            ic->streams[i]->discard= AVDISCARD_ALL;
3193
        }
3194
        for(i=0; i<ic->nb_programs; i++){
3195
            AVProgram *p= ic->programs[i];
3196
            if(p->id != opt_programid){
3197
                p->discard = AVDISCARD_ALL;
3198
            }else{
3199
                found=1;
3200
                for(j=0; j<p->nb_stream_indexes; j++){
3201
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3202
                }
3203
            }
3204
        }
3205
        if(!found){
3206
            fprintf(stderr, "Specified program id not found\n");
3207
            ffmpeg_exit(1);
3208
        }
3209
        opt_programid=0;
3210
    }
3211

    
3212
    ic->loop_input = loop_input;
3213

    
3214
    /* If not enough info to get the stream parameters, we decode the
3215
       first frames to get it. (used in mpeg case for example) */
3216
    ret = av_find_stream_info(ic);
3217
    if (ret < 0 && verbose >= 0) {
3218
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3219
        av_close_input_file(ic);
3220
        ffmpeg_exit(1);
3221
    }
3222

    
3223
    timestamp = start_time;
3224
    /* add the stream start time */
3225
    if (ic->start_time != AV_NOPTS_VALUE)
3226
        timestamp += ic->start_time;
3227

    
3228
    /* if seeking requested, we execute it */
3229
    if (start_time != 0) {
3230
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3231
        if (ret < 0) {
3232
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3233
                    filename, (double)timestamp / AV_TIME_BASE);
3234
        }
3235
        /* reset seek info */
3236
        start_time = 0;
3237
    }
3238

    
3239
    /* update the current parameters so that they match the one of the input stream */
3240
    for(i=0;i<ic->nb_streams;i++) {
3241
        AVStream *st = ic->streams[i];
3242
        AVCodecContext *dec = st->codec;
3243
        avcodec_thread_init(dec, thread_count);
3244
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3245
        switch (dec->codec_type) {
3246
        case AVMEDIA_TYPE_AUDIO:
3247
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3248
            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]);
3249
            //fprintf(stderr, "\nInput Audio channels: %d", dec->channels);
3250
            channel_layout    = dec->channel_layout;
3251
            audio_channels    = dec->channels;
3252
            audio_sample_rate = dec->sample_rate;
3253
            audio_sample_fmt  = dec->sample_fmt;
3254
            if(audio_disable)
3255
                st->discard= AVDISCARD_ALL;
3256
            /* Note that av_find_stream_info can add more streams, and we
3257
             * currently have no chance of setting up lowres decoding
3258
             * early enough for them. */
3259
            if (dec->lowres)
3260
                audio_sample_rate >>= dec->lowres;
3261
            break;
3262
        case AVMEDIA_TYPE_VIDEO:
3263
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3264
            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]);
3265
            frame_height = dec->height;
3266
            frame_width  = dec->width;
3267
            if(ic->streams[i]->sample_aspect_ratio.num)
3268
                frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3269
            else
3270
                frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3271
            frame_aspect_ratio *= (float) dec->width / dec->height;
3272
            frame_pix_fmt = dec->pix_fmt;
3273
            rfps      = ic->streams[i]->r_frame_rate.num;
3274
            rfps_base = ic->streams[i]->r_frame_rate.den;
3275
            if (dec->lowres) {
3276
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3277
                frame_height >>= dec->lowres;
3278
                frame_width  >>= dec->lowres;
3279
                dec->height = frame_height;
3280
                dec->width  = frame_width;
3281
            }
3282
            if(me_threshold)
3283
                dec->debug |= FF_DEBUG_MV;
3284

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

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

    
3291
                    (float)rfps / rfps_base, rfps, rfps_base);
3292
            }
3293
            /* update the current frame rate to match the stream frame rate */
3294
            frame_rate.num = rfps;
3295
            frame_rate.den = rfps_base;
3296

    
3297
            if(video_disable)
3298
                st->discard= AVDISCARD_ALL;
3299
            else if(video_discard)
3300
                st->discard= video_discard;
3301
            break;
3302
        case AVMEDIA_TYPE_DATA:
3303
            break;
3304
        case AVMEDIA_TYPE_SUBTITLE:
3305
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3306
            if(subtitle_disable)
3307
                st->discard = AVDISCARD_ALL;
3308
            break;
3309
        case AVMEDIA_TYPE_ATTACHMENT:
3310
        case AVMEDIA_TYPE_UNKNOWN:
3311
            break;
3312
        default:
3313
            abort();
3314
        }
3315
    }
3316

    
3317
    input_files[nb_input_files] = ic;
3318
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3319
    /* dump the file content */
3320
    if (verbose >= 0)
3321
        dump_format(ic, nb_input_files, filename, 0);
3322

    
3323
    nb_input_files++;
3324

    
3325
    video_channel = 0;
3326

    
3327
    av_freep(&video_codec_name);
3328
    av_freep(&audio_codec_name);
3329
    av_freep(&subtitle_codec_name);
3330
}
3331

    
3332
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3333
                                         int *has_subtitle_ptr)
3334
{
3335
    int has_video, has_audio, has_subtitle, i, j;
3336
    AVFormatContext *ic;
3337

    
3338
    has_video = 0;
3339
    has_audio = 0;
3340
    has_subtitle = 0;
3341
    for(j=0;j<nb_input_files;j++) {
3342
        ic = input_files[j];
3343
        for(i=0;i<ic->nb_streams;i++) {
3344
            AVCodecContext *enc = ic->streams[i]->codec;
3345
            switch(enc->codec_type) {
3346
            case AVMEDIA_TYPE_AUDIO:
3347
                has_audio = 1;
3348
                break;
3349
            case AVMEDIA_TYPE_VIDEO:
3350
                has_video = 1;
3351
                break;
3352
            case AVMEDIA_TYPE_SUBTITLE:
3353
                has_subtitle = 1;
3354
                break;
3355
            case AVMEDIA_TYPE_DATA:
3356
            case AVMEDIA_TYPE_ATTACHMENT:
3357
            case AVMEDIA_TYPE_UNKNOWN:
3358
                break;
3359
            default:
3360
                abort();
3361
            }
3362
        }
3363
    }
3364
    *has_video_ptr = has_video;
3365
    *has_audio_ptr = has_audio;
3366
    *has_subtitle_ptr = has_subtitle;
3367
}
3368

    
3369
static void new_video_stream(AVFormatContext *oc, int file_idx)
3370
{
3371
    AVStream *st;
3372
    AVOutputStream *ost;
3373
    AVCodecContext *video_enc;
3374
    enum CodecID codec_id = CODEC_ID_NONE;
3375
    AVCodec *codec= NULL;
3376

    
3377
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3378
    if (!st) {
3379
        fprintf(stderr, "Could not alloc stream\n");
3380
        ffmpeg_exit(1);
3381
    }
3382
    ost = new_output_stream(oc, file_idx);
3383

    
3384
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3385
    if(!video_stream_copy){
3386
        if (video_codec_name) {
3387
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3388
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3389
            codec = avcodec_find_encoder_by_name(video_codec_name);
3390
            output_codecs[nb_output_codecs-1] = codec;
3391
        } else {
3392
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3393
            codec = avcodec_find_encoder(codec_id);
3394
        }
3395
    }
3396

    
3397
    avcodec_get_context_defaults3(st->codec, codec);
3398
    ost->bitstream_filters = video_bitstream_filters;
3399
    video_bitstream_filters= NULL;
3400

    
3401
    avcodec_thread_init(st->codec, thread_count);
3402

    
3403
    video_enc = st->codec;
3404

    
3405
    if(video_codec_tag)
3406
        video_enc->codec_tag= video_codec_tag;
3407

    
3408
    if(   (video_global_header&1)
3409
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3410
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3411
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3412
    }
3413
    if(video_global_header&2){
3414
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3415
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3416
    }
3417

    
3418
    if (video_stream_copy) {
3419
        st->stream_copy = 1;
3420
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3421
        video_enc->sample_aspect_ratio =
3422
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3423
    } else {
3424
        const char *p;
3425
        int i;
3426
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3427

    
3428
        video_enc->codec_id = codec_id;
3429
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3430

    
3431
        if (codec && codec->supported_framerates && !force_fps)
3432
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3433
        video_enc->time_base.den = fps.num;
3434
        video_enc->time_base.num = fps.den;
3435

    
3436
        video_enc->width = frame_width;
3437
        video_enc->height = frame_height;
3438
        video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3439
        video_enc->pix_fmt = frame_pix_fmt;
3440
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3441

    
3442
        choose_pixel_fmt(st, codec);
3443

    
3444
        if (intra_only)
3445
            video_enc->gop_size = 0;
3446
        if (video_qscale || same_quality) {
3447
            video_enc->flags |= CODEC_FLAG_QSCALE;
3448
            video_enc->global_quality=
3449
                st->quality = FF_QP2LAMBDA * video_qscale;
3450
        }
3451

    
3452
        if(intra_matrix)
3453
            video_enc->intra_matrix = intra_matrix;
3454
        if(inter_matrix)
3455
            video_enc->inter_matrix = inter_matrix;
3456

    
3457
        p= video_rc_override_string;
3458
        for(i=0; p; i++){
3459
            int start, end, q;
3460
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3461
            if(e!=3){
3462
                fprintf(stderr, "error parsing rc_override\n");
3463
                ffmpeg_exit(1);
3464
            }
3465
            video_enc->rc_override=
3466
                av_realloc(video_enc->rc_override,
3467
                           sizeof(RcOverride)*(i+1));
3468
            video_enc->rc_override[i].start_frame= start;
3469
            video_enc->rc_override[i].end_frame  = end;
3470
            if(q>0){
3471
                video_enc->rc_override[i].qscale= q;
3472
                video_enc->rc_override[i].quality_factor= 1.0;
3473
            }
3474
            else{
3475
                video_enc->rc_override[i].qscale= 0;
3476
                video_enc->rc_override[i].quality_factor= -q/100.0;
3477
            }
3478
            p= strchr(p, '/');
3479
            if(p) p++;
3480
        }
3481
        video_enc->rc_override_count=i;
3482
        if (!video_enc->rc_initial_buffer_occupancy)
3483
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3484
        video_enc->me_threshold= me_threshold;
3485
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3486

    
3487
        if (do_psnr)
3488
            video_enc->flags|= CODEC_FLAG_PSNR;
3489

    
3490
        /* two pass mode */
3491
        if (do_pass) {
3492
            if (do_pass == 1) {
3493
                video_enc->flags |= CODEC_FLAG_PASS1;
3494
            } else {
3495
                video_enc->flags |= CODEC_FLAG_PASS2;
3496
            }
3497
        }
3498

    
3499
        if (forced_key_frames)
3500
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3501
    }
3502
    if (video_language) {
3503
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3504
        av_freep(&video_language);
3505
    }
3506

    
3507
    /* reset some key parameters */
3508
    video_disable = 0;
3509
    av_freep(&video_codec_name);
3510
    av_freep(&forced_key_frames);
3511
    video_stream_copy = 0;
3512
    frame_pix_fmt = PIX_FMT_NONE;
3513
}
3514

    
3515
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3516
{
3517
    AVStream *st;
3518
    AVOutputStream *ost;
3519
    AVCodec *codec= NULL;
3520
    AVCodecContext *audio_enc;
3521
    enum CodecID codec_id = CODEC_ID_NONE;
3522

    
3523
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3524
    if (!st) {
3525
        fprintf(stderr, "Could not alloc stream\n");
3526
        ffmpeg_exit(1);
3527
    }
3528
    ost = new_output_stream(oc, file_idx);
3529

    
3530
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3531
    if(!audio_stream_copy){
3532
        if (audio_codec_name) {
3533
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3534
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3535
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3536
            output_codecs[nb_output_codecs-1] = codec;
3537
        } else {
3538
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3539
            codec = avcodec_find_encoder(codec_id);
3540
        }
3541
    }
3542

    
3543
    avcodec_get_context_defaults3(st->codec, codec);
3544

    
3545
    ost->bitstream_filters = audio_bitstream_filters;
3546
    audio_bitstream_filters= NULL;
3547

    
3548
    avcodec_thread_init(st->codec, thread_count);
3549

    
3550
    audio_enc = st->codec;
3551
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3552

    
3553
    if(audio_codec_tag)
3554
        audio_enc->codec_tag= audio_codec_tag;
3555

    
3556
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3557
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3558
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3559
    }
3560
    if (audio_stream_copy) {
3561
        st->stream_copy = 1;
3562
        audio_enc->channels = audio_channels;
3563
        audio_enc->sample_rate = audio_sample_rate;
3564
    } else {
3565
        audio_enc->codec_id = codec_id;
3566
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3567

    
3568
        if (audio_qscale > QSCALE_NONE) {
3569
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3570
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3571
        }
3572
        audio_enc->channels = audio_channels;
3573
        audio_enc->sample_fmt = audio_sample_fmt;
3574
        audio_enc->sample_rate = audio_sample_rate;
3575
        audio_enc->channel_layout = channel_layout;
3576
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3577
            audio_enc->channel_layout = 0;
3578
        choose_sample_fmt(st, codec);
3579
        choose_sample_rate(st, codec);
3580
    }
3581
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3582
    if (audio_language) {
3583
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3584
        av_freep(&audio_language);
3585
    }
3586

    
3587
    /* reset some key parameters */
3588
    audio_disable = 0;
3589
    av_freep(&audio_codec_name);
3590
    audio_stream_copy = 0;
3591
}
3592

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

    
3601
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3602
    if (!st) {
3603
        fprintf(stderr, "Could not alloc stream\n");
3604
        ffmpeg_exit(1);
3605
    }
3606
    ost = new_output_stream(oc, file_idx);
3607
    subtitle_enc = st->codec;
3608
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3609
    if(!subtitle_stream_copy){
3610
        if (subtitle_codec_name) {
3611
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3612
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3613
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3614
        } else {
3615
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3616
            codec = avcodec_find_encoder(codec_id);
3617
        }
3618
    }
3619
    avcodec_get_context_defaults3(st->codec, codec);
3620

    
3621
    ost->bitstream_filters = subtitle_bitstream_filters;
3622
    subtitle_bitstream_filters= NULL;
3623

    
3624
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3625

    
3626
    if(subtitle_codec_tag)
3627
        subtitle_enc->codec_tag= subtitle_codec_tag;
3628

    
3629
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3630
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3631
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3632
    }
3633
    if (subtitle_stream_copy) {
3634
        st->stream_copy = 1;
3635
    } else {
3636
        subtitle_enc->codec_id = codec_id;
3637
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3638
    }
3639

    
3640
    if (subtitle_language) {
3641
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3642
        av_freep(&subtitle_language);
3643
    }
3644

    
3645
    subtitle_disable = 0;
3646
    av_freep(&subtitle_codec_name);
3647
    subtitle_stream_copy = 0;
3648
}
3649

    
3650
static int opt_new_stream(const char *opt, const char *arg)
3651
{
3652
    AVFormatContext *oc;
3653
    int file_idx = nb_output_files - 1;
3654
    if (nb_output_files <= 0) {
3655
        fprintf(stderr, "At least one output file must be specified\n");
3656
        ffmpeg_exit(1);
3657
    }
3658
    oc = output_files[file_idx];
3659

    
3660
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3661
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3662
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3663
    else av_assert0(0);
3664
    return 0;
3665
}
3666

    
3667
/* arg format is "output-stream-index:streamid-value". */
3668
static int opt_streamid(const char *opt, const char *arg)
3669
{
3670
    int idx;
3671
    char *p;
3672
    char idx_str[16];
3673

    
3674
    strncpy(idx_str, arg, sizeof(idx_str));
3675
    idx_str[sizeof(idx_str)-1] = '\0';
3676
    p = strchr(idx_str, ':');
3677
    if (!p) {
3678
        fprintf(stderr,
3679
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3680
                arg, opt);
3681
        ffmpeg_exit(1);
3682
    }
3683
    *p++ = '\0';
3684
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3685
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3686
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3687
    return 0;
3688
}
3689

    
3690
static void opt_output_file(const char *filename)
3691
{
3692
    AVFormatContext *oc;
3693
    int err, use_video, use_audio, use_subtitle;
3694
    int input_has_video, input_has_audio, input_has_subtitle;
3695
    AVFormatParameters params, *ap = &params;
3696
    AVOutputFormat *file_oformat;
3697

    
3698
    if (!strcmp(filename, "-"))
3699
        filename = "pipe:";
3700

    
3701
    oc = avformat_alloc_context();
3702
    if (!oc) {
3703
        print_error(filename, AVERROR(ENOMEM));
3704
        ffmpeg_exit(1);
3705
    }
3706

    
3707
    if (last_asked_format) {
3708
        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3709
        if (!file_oformat) {
3710
            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3711
            ffmpeg_exit(1);
3712
        }
3713
        last_asked_format = NULL;
3714
    } else {
3715
        file_oformat = av_guess_format(NULL, filename, NULL);
3716
        if (!file_oformat) {
3717
            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3718
                    filename);
3719
            ffmpeg_exit(1);
3720
        }
3721
    }
3722

    
3723
    oc->oformat = file_oformat;
3724
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3725

    
3726
    if (!strcmp(file_oformat->name, "ffm") &&
3727
        av_strstart(filename, "http:", NULL)) {
3728
        /* special case for files sent to ffserver: we get the stream
3729
           parameters from ffserver */
3730
        int err = read_ffserver_streams(oc, filename);
3731
        if (err < 0) {
3732
            print_error(filename, err);
3733
            ffmpeg_exit(1);
3734
        }
3735
    } else {
3736
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3737
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3738
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3739

    
3740
        /* disable if no corresponding type found and at least one
3741
           input file */
3742
        if (nb_input_files > 0) {
3743
            check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3744
                                         &input_has_subtitle);
3745
            if (!input_has_video)
3746
                use_video = 0;
3747
            if (!input_has_audio)
3748
                use_audio = 0;
3749
            if (!input_has_subtitle)
3750
                use_subtitle = 0;
3751
        }
3752

    
3753
        /* manual disable */
3754
        if (audio_disable)    use_audio    = 0;
3755
        if (video_disable)    use_video    = 0;
3756
        if (subtitle_disable) use_subtitle = 0;
3757

    
3758
        if (use_video)    new_video_stream(oc, nb_output_files);
3759
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3760
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3761

    
3762
        oc->timestamp = recording_timestamp;
3763

    
3764
        av_metadata_copy(&oc->metadata, metadata, 0);
3765
        av_metadata_free(&metadata);
3766
    }
3767

    
3768
    output_files[nb_output_files++] = oc;
3769

    
3770
    /* check filename in case of an image number is expected */
3771
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3772
        if (!av_filename_number_test(oc->filename)) {
3773
            print_error(oc->filename, AVERROR_NUMEXPECTED);
3774
            ffmpeg_exit(1);
3775
        }
3776
    }
3777

    
3778
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3779
        /* test if it already exists to avoid loosing precious files */
3780
        if (!file_overwrite &&
3781
            (strchr(filename, ':') == NULL ||
3782
             filename[1] == ':' ||
3783
             av_strstart(filename, "file:", NULL))) {
3784
            if (url_exist(filename)) {
3785
                if (!using_stdin) {
3786
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3787
                    fflush(stderr);
3788
                    if (!read_yesno()) {
3789
                        fprintf(stderr, "Not overwriting - exiting\n");
3790
                        ffmpeg_exit(1);
3791
                    }
3792
                }
3793
                else {
3794
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3795
                    ffmpeg_exit(1);
3796
                }
3797
            }
3798
        }
3799

    
3800
        /* open the file */
3801
        if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) {
3802
            print_error(filename, err);
3803
            ffmpeg_exit(1);
3804
        }
3805
    }
3806

    
3807
    memset(ap, 0, sizeof(*ap));
3808
    if (av_set_parameters(oc, ap) < 0) {
3809
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3810
                oc->filename);
3811
        ffmpeg_exit(1);
3812
    }
3813

    
3814
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3815
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3816
    oc->loop_output = loop_output;
3817
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3818

    
3819
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3820

    
3821
    av_freep(&forced_key_frames);
3822
}
3823

    
3824
/* same option as mencoder */
3825
static void opt_pass(const char *pass_str)
3826
{
3827
    int pass;
3828
    pass = atoi(pass_str);
3829
    if (pass != 1 && pass != 2) {
3830
        fprintf(stderr, "pass number can be only 1 or 2\n");
3831
        ffmpeg_exit(1);
3832
    }
3833
    do_pass = pass;
3834
}
3835

    
3836
static int64_t getutime(void)
3837
{
3838
#if HAVE_GETRUSAGE
3839
    struct rusage rusage;
3840

    
3841
    getrusage(RUSAGE_SELF, &rusage);
3842
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3843
#elif HAVE_GETPROCESSTIMES
3844
    HANDLE proc;
3845
    FILETIME c, e, k, u;
3846
    proc = GetCurrentProcess();
3847
    GetProcessTimes(proc, &c, &e, &k, &u);
3848
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3849
#else
3850
    return av_gettime();
3851
#endif
3852
}
3853

    
3854
static int64_t getmaxrss(void)
3855
{
3856
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3857
    struct rusage rusage;
3858
    getrusage(RUSAGE_SELF, &rusage);
3859
    return (int64_t)rusage.ru_maxrss * 1024;
3860
#elif HAVE_GETPROCESSMEMORYINFO
3861
    HANDLE proc;
3862
    PROCESS_MEMORY_COUNTERS memcounters;
3863
    proc = GetCurrentProcess();
3864
    memcounters.cb = sizeof(memcounters);
3865
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3866
    return memcounters.PeakPagefileUsage;
3867
#else
3868
    return 0;
3869
#endif
3870
}
3871

    
3872
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3873
{
3874
    int i;
3875
    const char *p = str;
3876
    for(i = 0;; i++) {
3877
        dest[i] = atoi(p);
3878
        if(i == 63)
3879
            break;
3880
        p = strchr(p, ',');
3881
        if(!p) {
3882
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3883
            ffmpeg_exit(1);
3884
        }
3885
        p++;
3886
    }
3887
}
3888

    
3889
static void opt_inter_matrix(const char *arg)
3890
{
3891
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3892
    parse_matrix_coeffs(inter_matrix, arg);
3893
}
3894

    
3895
static void opt_intra_matrix(const char *arg)
3896
{
3897
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3898
    parse_matrix_coeffs(intra_matrix, arg);
3899
}
3900

    
3901
static void show_usage(void)
3902
{
3903
    printf("Hyper fast Audio and Video encoder\n");
3904
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3905
    printf("\n");
3906
}
3907

    
3908
static void show_help(void)
3909
{
3910
    AVCodec *c;
3911
    AVOutputFormat *oformat = NULL;
3912

    
3913
    av_log_set_callback(log_callback_help);
3914
    show_usage();
3915
    show_help_options(options, "Main options:\n",
3916
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3917
    show_help_options(options, "\nAdvanced options:\n",
3918
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3919
                      OPT_EXPERT);
3920
    show_help_options(options, "\nVideo options:\n",
3921
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3922
                      OPT_VIDEO);
3923
    show_help_options(options, "\nAdvanced Video options:\n",
3924
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3925
                      OPT_VIDEO | OPT_EXPERT);
3926
    show_help_options(options, "\nAudio options:\n",
3927
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3928
                      OPT_AUDIO);
3929
    show_help_options(options, "\nAdvanced Audio options:\n",
3930
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3931
                      OPT_AUDIO | OPT_EXPERT);
3932
    show_help_options(options, "\nSubtitle options:\n",
3933
                      OPT_SUBTITLE | OPT_GRAB,
3934
                      OPT_SUBTITLE);
3935
    show_help_options(options, "\nAudio/Video grab options:\n",
3936
                      OPT_GRAB,
3937
                      OPT_GRAB);
3938
    printf("\n");
3939
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3940
    printf("\n");
3941

    
3942
    /* individual codec options */
3943
    c = NULL;
3944
    while ((c = av_codec_next(c))) {
3945
        if (c->priv_class) {
3946
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3947
            printf("\n");
3948
        }
3949
    }
3950

    
3951
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3952
    printf("\n");
3953

    
3954
    /* individual muxer options */
3955
    while ((oformat = av_oformat_next(oformat))) {
3956
        if (oformat->priv_class) {
3957
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3958
            printf("\n");
3959
        }
3960
    }
3961

    
3962
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3963
}
3964

    
3965
static void opt_target(const char *arg)
3966
{
3967
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3968
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3969

    
3970
    if(!strncmp(arg, "pal-", 4)) {
3971
        norm = PAL;
3972
        arg += 4;
3973
    } else if(!strncmp(arg, "ntsc-", 5)) {
3974
        norm = NTSC;
3975
        arg += 5;
3976
    } else if(!strncmp(arg, "film-", 5)) {
3977
        norm = FILM;
3978
        arg += 5;
3979
    } else {
3980
        int fr;
3981
        /* Calculate FR via float to avoid int overflow */
3982
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3983
        if(fr == 25000) {
3984
            norm = PAL;
3985
        } else if((fr == 29970) || (fr == 23976)) {
3986
            norm = NTSC;
3987
        } else {
3988
            /* Try to determine PAL/NTSC by peeking in the input files */
3989
            if(nb_input_files) {
3990
                int i, j;
3991
                for(j = 0; j < nb_input_files; j++) {
3992
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
3993
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
3994
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3995
                            continue;
3996
                        fr = c->time_base.den * 1000 / c->time_base.num;
3997
                        if(fr == 25000) {
3998
                            norm = PAL;
3999
                            break;
4000
                        } else if((fr == 29970) || (fr == 23976)) {
4001
                            norm = NTSC;
4002
                            break;
4003
                        }
4004
                    }
4005
                    if(norm != UNKNOWN)
4006
                        break;
4007
                }
4008
            }
4009
        }
4010
        if(verbose && norm != UNKNOWN)
4011
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4012
    }
4013

    
4014
    if(norm == UNKNOWN) {
4015
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4016
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4017
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4018
        ffmpeg_exit(1);
4019
    }
4020

    
4021
    if(!strcmp(arg, "vcd")) {
4022

    
4023
        opt_video_codec("mpeg1video");
4024
        opt_audio_codec("mp2");
4025
        opt_format("vcd");
4026

    
4027
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4028
        opt_frame_rate(NULL, frame_rates[norm]);
4029
        opt_default("g", norm == PAL ? "15" : "18");
4030

    
4031
        opt_default("b", "1150000");
4032
        opt_default("maxrate", "1150000");
4033
        opt_default("minrate", "1150000");
4034
        opt_default("bufsize", "327680"); // 40*1024*8;
4035

    
4036
        opt_default("ab", "224000");
4037
        audio_sample_rate = 44100;
4038
        audio_channels = 2;
4039

    
4040
        opt_default("packetsize", "2324");
4041
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4042

    
4043
        /* We have to offset the PTS, so that it is consistent with the SCR.
4044
           SCR starts at 36000, but the first two packs contain only padding
4045
           and the first pack from the other stream, respectively, may also have
4046
           been written before.
4047
           So the real data starts at SCR 36000+3*1200. */
4048
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4049
    } else if(!strcmp(arg, "svcd")) {
4050

    
4051
        opt_video_codec("mpeg2video");
4052
        opt_audio_codec("mp2");
4053
        opt_format("svcd");
4054

    
4055
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4056
        opt_frame_rate(NULL, frame_rates[norm]);
4057
        opt_default("g", norm == PAL ? "15" : "18");
4058

    
4059
        opt_default("b", "2040000");
4060
        opt_default("maxrate", "2516000");
4061
        opt_default("minrate", "0"); //1145000;
4062
        opt_default("bufsize", "1835008"); //224*1024*8;
4063
        opt_default("flags", "+scan_offset");
4064

    
4065

    
4066
        opt_default("ab", "224000");
4067
        audio_sample_rate = 44100;
4068

    
4069
        opt_default("packetsize", "2324");
4070

    
4071
    } else if(!strcmp(arg, "dvd")) {
4072

    
4073
        opt_video_codec("mpeg2video");
4074
        opt_audio_codec("ac3");
4075
        opt_format("dvd");
4076

    
4077
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4078
        opt_frame_rate(NULL, frame_rates[norm]);
4079
        opt_default("g", norm == PAL ? "15" : "18");
4080

    
4081
        opt_default("b", "6000000");
4082
        opt_default("maxrate", "9000000");
4083
        opt_default("minrate", "0"); //1500000;
4084
        opt_default("bufsize", "1835008"); //224*1024*8;
4085

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

    
4089
        opt_default("ab", "448000");
4090
        audio_sample_rate = 48000;
4091

    
4092
    } else if(!strncmp(arg, "dv", 2)) {
4093

    
4094
        opt_format("dv");
4095

    
4096
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4097
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4098
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4099
        opt_frame_rate(NULL, frame_rates[norm]);
4100

    
4101
        audio_sample_rate = 48000;
4102
        audio_channels = 2;
4103

    
4104
    } else {
4105
        fprintf(stderr, "Unknown target: %s\n", arg);
4106
        ffmpeg_exit(1);
4107
    }
4108
}
4109

    
4110
static void opt_vstats_file (const char *arg)
4111
{
4112
    av_free (vstats_filename);
4113
    vstats_filename=av_strdup (arg);
4114
}
4115

    
4116
static void opt_vstats (void)
4117
{
4118
    char filename[40];
4119
    time_t today2 = time(NULL);
4120
    struct tm *today = localtime(&today2);
4121

    
4122
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4123
             today->tm_sec);
4124
    opt_vstats_file(filename);
4125
}
4126

    
4127
static int opt_bsf(const char *opt, const char *arg)
4128
{
4129
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4130
    AVBitStreamFilterContext **bsfp;
4131

    
4132
    if(!bsfc){
4133
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4134
        ffmpeg_exit(1);
4135
    }
4136

    
4137
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4138
          *opt == 'a' ? &audio_bitstream_filters :
4139
                        &subtitle_bitstream_filters;
4140
    while(*bsfp)
4141
        bsfp= &(*bsfp)->next;
4142

    
4143
    *bsfp= bsfc;
4144

    
4145
    return 0;
4146
}
4147

    
4148
static int opt_preset(const char *opt, const char *arg)
4149
{
4150
    FILE *f=NULL;
4151
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4152
    char *codec_name = *opt == 'v' ? video_codec_name :
4153
                       *opt == 'a' ? audio_codec_name :
4154
                                     subtitle_codec_name;
4155

    
4156
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4157
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4158
        ffmpeg_exit(1);
4159
    }
4160

    
4161
    while(!feof(f)){
4162
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4163
        if(line[0] == '#' && !e)
4164
            continue;
4165
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4166
        if(e){
4167
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4168
            ffmpeg_exit(1);
4169
        }
4170
        if(!strcmp(tmp, "acodec")){
4171
            opt_audio_codec(tmp2);
4172
        }else if(!strcmp(tmp, "vcodec")){
4173
            opt_video_codec(tmp2);
4174
        }else if(!strcmp(tmp, "scodec")){
4175
            opt_subtitle_codec(tmp2);
4176
        }else if(opt_default(tmp, tmp2) < 0){
4177
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4178
            ffmpeg_exit(1);
4179
        }
4180
    }
4181

    
4182
    fclose(f);
4183

    
4184
    return 0;
4185
}
4186

    
4187
static const OptionDef options[] = {
4188
    /* main options */
4189
#include "cmdutils_common_opts.h"
4190
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4191
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4192
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4193
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4194
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile[,metadata]:infile[,metadata]" },
4195
    { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4196
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4197
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4198
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4199
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4200
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4201
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4202
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4203
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4204
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4205
      "add timings for benchmarking" },
4206
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4207
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4208
      "dump each input packet" },
4209
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4210
      "when dumping packets, also dump the payload" },
4211
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4212
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4213
    { "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)", "" },
4214
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4215
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4216
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4217
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4218
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4219
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4220
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4221
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4222
    { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4223
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4224
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4225
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4226
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4227
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4228

    
4229
    /* video options */
4230
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4231
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4232
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4233
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4234
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4235
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4236
    { "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" },
4237
    { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4238
    { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4239
    { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4240
    { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4241
    { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4242
    { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4243
    { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4244
    { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4245
    { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4246
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4247
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4248
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4249
    { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4250
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4251
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4252
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4253
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4254
      "use same video quality as source (implies VBR)" },
4255
    { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4256
    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4257
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4258
      "deinterlace pictures" },
4259
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4260
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4261
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4262
#if CONFIG_AVFILTER
4263
    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4264
#endif
4265
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4266
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4267
    { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4268
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4269
    { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4270
    { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4271
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4272
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4273
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4274
    { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4275
    { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4276

    
4277
    /* audio options */
4278
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4279
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4280
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4281
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4282
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4283
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4284
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4285
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4286
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4287
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4288
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4289
    { "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" },
4290

    
4291
    /* subtitle options */
4292
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4293
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4294
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4295
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4296
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4297

    
4298
    /* grab options */
4299
    { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4300
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4301
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4302

    
4303
    /* muxer options */
4304
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4305
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4306

    
4307
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4308
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4309
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4310

    
4311
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4312
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4313
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4314
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4315

    
4316
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4317
    { NULL, },
4318
};
4319

    
4320
int main(int argc, char **argv)
4321
{
4322
    int64_t ti;
4323

    
4324
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4325

    
4326
    avcodec_register_all();
4327
#if CONFIG_AVDEVICE
4328
    avdevice_register_all();
4329
#endif
4330
#if CONFIG_AVFILTER
4331
    avfilter_register_all();
4332
#endif
4333
    av_register_all();
4334

    
4335
#if HAVE_ISATTY
4336
    if(isatty(STDIN_FILENO))
4337
        url_set_interrupt_cb(decode_interrupt_cb);
4338
#endif
4339

    
4340
    init_opts();
4341

    
4342
    show_banner();
4343

    
4344
    /* parse options */
4345
    parse_options(argc, argv, options, opt_output_file);
4346

    
4347
    if(nb_output_files <= 0 && nb_input_files == 0) {
4348
        show_usage();
4349
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4350
        ffmpeg_exit(1);
4351
    }
4352

    
4353
    /* file converter / grab */
4354
    if (nb_output_files <= 0) {
4355
        fprintf(stderr, "At least one output file must be specified\n");
4356
        ffmpeg_exit(1);
4357
    }
4358

    
4359
    if (nb_input_files == 0) {
4360
        fprintf(stderr, "At least one input file must be specified\n");
4361
        ffmpeg_exit(1);
4362
    }
4363

    
4364
    ti = getutime();
4365
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4366
                  stream_maps, nb_stream_maps) < 0)
4367
        ffmpeg_exit(1);
4368
    ti = getutime() - ti;
4369
    if (do_benchmark) {
4370
        int maxrss = getmaxrss() / 1024;
4371
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4372
    }
4373

    
4374
    return ffmpeg_exit(0);
4375
}