Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 6b474953

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
        AVFormatContext *s = output_files[i];
509
        int j;
510
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
511
            url_fclose(s->pb);
512
        avformat_free_context(s);
513
        av_free(output_streams_for_file[i]);
514
    }
515
    for(i=0;i<nb_input_files;i++) {
516
        av_close_input_file(input_files[i]);
517
        av_free(input_files_ts_scale[i]);
518
    }
519

    
520
    av_free(intra_matrix);
521
    av_free(inter_matrix);
522

    
523
    if (vstats_file)
524
        fclose(vstats_file);
525
    av_free(vstats_filename);
526

    
527
    av_free(opt_names);
528
    av_free(streamid_map);
529
    av_free(input_codecs);
530
    av_free(output_codecs);
531
    av_free(stream_maps);
532
    av_free(meta_data_maps);
533

    
534
    av_free(video_codec_name);
535
    av_free(audio_codec_name);
536
    av_free(subtitle_codec_name);
537

    
538
    av_free(video_standard);
539

    
540
    uninit_opts();
541
    av_free(audio_buf);
542
    av_free(audio_out);
543
    allocated_audio_buf_size= allocated_audio_out_size= 0;
544
    av_free(samples);
545

    
546
#if CONFIG_AVFILTER
547
    avfilter_uninit();
548
#endif
549

    
550
    if (received_sigterm) {
551
        fprintf(stderr,
552
            "Received signal %d: terminating.\n",
553
            (int) received_sigterm);
554
        exit (255);
555
    }
556

    
557
    exit(ret); /* not all OS-es handle main() return value */
558
    return ret;
559
}
560

    
561
/* similar to ff_dynarray_add() and av_fast_realloc() */
562
static void *grow_array(void *array, int elem_size, int *size, int new_size)
563
{
564
    if (new_size >= INT_MAX / elem_size) {
565
        fprintf(stderr, "Array too big.\n");
566
        ffmpeg_exit(1);
567
    }
568
    if (*size < new_size) {
569
        uint8_t *tmp = av_realloc(array, new_size*elem_size);
570
        if (!tmp) {
571
            fprintf(stderr, "Could not alloc buffer.\n");
572
            ffmpeg_exit(1);
573
        }
574
        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
575
        *size = new_size;
576
        return tmp;
577
    }
578
    return array;
579
}
580

    
581
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
582
{
583
    if(codec && codec->sample_fmts){
584
        const enum AVSampleFormat *p= codec->sample_fmts;
585
        for(; *p!=-1; p++){
586
            if(*p == st->codec->sample_fmt)
587
                break;
588
        }
589
        if (*p == -1) {
590
            av_log(NULL, AV_LOG_WARNING,
591
                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
592
                   av_get_sample_fmt_name(st->codec->sample_fmt),
593
                   codec->name,
594
                   av_get_sample_fmt_name(codec->sample_fmts[0]));
595
            st->codec->sample_fmt = codec->sample_fmts[0];
596
        }
597
    }
598
}
599

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

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

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

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

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

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

    
676
        s->nb_streams++;
677

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

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

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

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

    
710
        new_output_stream(s, nb_output_files);
711
    }
712

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

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

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

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

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

    
749
        bsfc= bsfc->next;
750
    }
751

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

    
759
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
760

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

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

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

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

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

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

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

    
804
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
805
                       ost->resample_channels    != dec->channels   ||
806
                       ost->resample_sample_rate != dec->sample_rate;
807

    
808
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
809
        if (resample_changed) {
810
            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",
811
                   ist->file_index, ist->index,
812
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
813
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
814
            ost->resample_sample_fmt  = dec->sample_fmt;
815
            ost->resample_channels    = dec->channels;
816
            ost->resample_sample_rate = dec->sample_rate;
817
            if (ost->resample)
818
                audio_resample_close(ost->resample);
819
        }
820
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
821
        if (audio_sync_method <= 1 &&
822
            ost->resample_sample_fmt  == enc->sample_fmt &&
823
            ost->resample_channels    == enc->channels   &&
824
            ost->resample_sample_rate == enc->sample_rate) {
825
            ost->resample = NULL;
826
            ost->audio_resample = 0;
827
        } else {
828
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
829
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
830
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
831
                                                   enc->sample_rate, dec->sample_rate,
832
                                                   enc->sample_fmt,  dec->sample_fmt,
833
                                                   16, 10, 0, 0.8);
834
            if (!ost->resample) {
835
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
836
                        dec->channels, dec->sample_rate,
837
                        enc->channels, enc->sample_rate);
838
                ffmpeg_exit(1);
839
            }
840
        }
841
    }
842

    
843
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
844
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
845
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
846
        if (ost->reformat_ctx)
847
            av_audio_convert_free(ost->reformat_ctx);
848
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
849
                                                   dec->sample_fmt, 1, NULL, 0);
850
        if (!ost->reformat_ctx) {
851
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
852
                av_get_sample_fmt_name(dec->sample_fmt),
853
                av_get_sample_fmt_name(enc->sample_fmt));
854
            ffmpeg_exit(1);
855
        }
856
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
857
    }
858

    
859
    if(audio_sync_method){
860
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
861
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
862
        double idelta= delta*dec->sample_rate / enc->sample_rate;
863
        int byte_delta= ((int)idelta)*2*dec->channels;
864

    
865
        //FIXME resample delay
866
        if(fabs(delta) > 50){
867
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
868
                if(byte_delta < 0){
869
                    byte_delta= FFMAX(byte_delta, -size);
870
                    size += byte_delta;
871
                    buf  -= byte_delta;
872
                    if(verbose > 2)
873
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
874
                    if(!size)
875
                        return;
876
                    ist->is_start=0;
877
                }else{
878
                    static uint8_t *input_tmp= NULL;
879
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
880

    
881
                    if(byte_delta > allocated_for_size - size){
882
                        allocated_for_size= byte_delta + (int64_t)size;
883
                        goto need_realloc;
884
                    }
885
                    ist->is_start=0;
886

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

    
907
    if (ost->audio_resample) {
908
        buftmp = audio_buf;
909
        size_out = audio_resample(ost->resample,
910
                                  (short *)buftmp, (short *)buf,
911
                                  size / (dec->channels * isize));
912
        size_out = size_out * enc->channels * osize;
913
    } else {
914
        buftmp = buf;
915
        size_out = size;
916
    }
917

    
918
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
919
        const void *ibuf[6]= {buftmp};
920
        void *obuf[6]= {audio_buf};
921
        int istride[6]= {isize};
922
        int ostride[6]= {osize};
923
        int len= size_out/istride[0];
924
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
925
            printf("av_audio_convert() failed\n");
926
            if (exit_on_error)
927
                ffmpeg_exit(1);
928
            return;
929
        }
930
        buftmp = audio_buf;
931
        size_out = len*osize;
932
    }
933

    
934
    /* now encode as many frames as possible */
935
    if (enc->frame_size > 1) {
936
        /* output resampled raw samples */
937
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
938
            fprintf(stderr, "av_fifo_realloc2() failed\n");
939
            ffmpeg_exit(1);
940
        }
941
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
942

    
943
        frame_bytes = enc->frame_size * osize * enc->channels;
944

    
945
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
946
            AVPacket pkt;
947
            av_init_packet(&pkt);
948

    
949
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
950

    
951
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
952

    
953
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
954
                                       (short *)audio_buf);
955
            if (ret < 0) {
956
                fprintf(stderr, "Audio encoding failed\n");
957
                ffmpeg_exit(1);
958
            }
959
            audio_size += ret;
960
            pkt.stream_index= ost->index;
961
            pkt.data= audio_out;
962
            pkt.size= ret;
963
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
964
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
965
            pkt.flags |= AV_PKT_FLAG_KEY;
966
            write_frame(s, &pkt, enc, ost->bitstream_filters);
967

    
968
            ost->sync_opts += enc->frame_size;
969
        }
970
    } else {
971
        AVPacket pkt;
972
        av_init_packet(&pkt);
973

    
974
        ost->sync_opts += size_out / (osize * enc->channels);
975

    
976
        /* output a pcm frame */
977
        /* determine the size of the coded buffer */
978
        size_out /= osize;
979
        if (coded_bps)
980
            size_out = size_out*coded_bps/8;
981

    
982
        if(size_out > audio_out_size){
983
            fprintf(stderr, "Internal error, buffer size too small\n");
984
            ffmpeg_exit(1);
985
        }
986

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

    
1005
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1006
{
1007
    AVCodecContext *dec;
1008
    AVPicture *picture2;
1009
    AVPicture picture_tmp;
1010
    uint8_t *buf = 0;
1011

    
1012
    dec = ist->st->codec;
1013

    
1014
    /* deinterlace : must be done before any resize */
1015
    if (do_deinterlace) {
1016
        int size;
1017

    
1018
        /* create temporary picture */
1019
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1020
        buf = av_malloc(size);
1021
        if (!buf)
1022
            return;
1023

    
1024
        picture2 = &picture_tmp;
1025
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1026

    
1027
        if(avpicture_deinterlace(picture2, picture,
1028
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1029
            /* if error, do not deinterlace */
1030
            fprintf(stderr, "Deinterlacing failed\n");
1031
            av_free(buf);
1032
            buf = NULL;
1033
            picture2 = picture;
1034
        }
1035
    } else {
1036
        picture2 = picture;
1037
    }
1038

    
1039
    if (picture != picture2)
1040
        *picture = *picture2;
1041
    *bufp = buf;
1042
}
1043

    
1044
/* we begin to correct av delay at this threshold */
1045
#define AV_DELAY_MAX 0.100
1046

    
1047
static void do_subtitle_out(AVFormatContext *s,
1048
                            AVOutputStream *ost,
1049
                            AVInputStream *ist,
1050
                            AVSubtitle *sub,
1051
                            int64_t pts)
1052
{
1053
    static uint8_t *subtitle_out = NULL;
1054
    int subtitle_out_max_size = 1024 * 1024;
1055
    int subtitle_out_size, nb, i;
1056
    AVCodecContext *enc;
1057
    AVPacket pkt;
1058

    
1059
    if (pts == AV_NOPTS_VALUE) {
1060
        fprintf(stderr, "Subtitle packets must have a pts\n");
1061
        if (exit_on_error)
1062
            ffmpeg_exit(1);
1063
        return;
1064
    }
1065

    
1066
    enc = ost->st->codec;
1067

    
1068
    if (!subtitle_out) {
1069
        subtitle_out = av_malloc(subtitle_out_max_size);
1070
    }
1071

    
1072
    /* Note: DVB subtitle need one packet to draw them and one other
1073
       packet to clear them */
1074
    /* XXX: signal it in the codec context ? */
1075
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1076
        nb = 2;
1077
    else
1078
        nb = 1;
1079

    
1080
    for(i = 0; i < nb; i++) {
1081
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1082
        // start_display_time is required to be 0
1083
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1084
        sub->end_display_time -= sub->start_display_time;
1085
        sub->start_display_time = 0;
1086
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1087
                                                    subtitle_out_max_size, sub);
1088
        if (subtitle_out_size < 0) {
1089
            fprintf(stderr, "Subtitle encoding failed\n");
1090
            ffmpeg_exit(1);
1091
        }
1092

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

    
1110
static int bit_buffer_size= 1024*256;
1111
static uint8_t *bit_buffer= NULL;
1112

    
1113
static void do_video_out(AVFormatContext *s,
1114
                         AVOutputStream *ost,
1115
                         AVInputStream *ist,
1116
                         AVFrame *in_picture,
1117
                         int *frame_size)
1118
{
1119
    int nb_frames, i, ret;
1120
    AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
1121
    AVCodecContext *enc, *dec;
1122
    double sync_ipts;
1123

    
1124
    enc = ost->st->codec;
1125
    dec = ist->st->codec;
1126

    
1127
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1128

    
1129
    /* by default, we output a single frame */
1130
    nb_frames = 1;
1131

    
1132
    *frame_size = 0;
1133

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

    
1159
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1160
    if (nb_frames <= 0)
1161
        return;
1162

    
1163
    formatted_picture = in_picture;
1164
    final_picture = formatted_picture;
1165
    padding_src = formatted_picture;
1166
    resampling_dst = &ost->pict_tmp;
1167

    
1168
    if (   ost->resample_height != ist->st->codec->height
1169
        || ost->resample_width  != ist->st->codec->width
1170
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1171

    
1172
        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));
1173
        if(!ost->video_resample)
1174
            ffmpeg_exit(1);
1175
    }
1176

    
1177
#if !CONFIG_AVFILTER
1178
    if (ost->video_resample) {
1179
        padding_src = NULL;
1180
        final_picture = &ost->pict_tmp;
1181
        if(  ost->resample_height != ist->st->codec->height
1182
          || ost->resample_width  != ist->st->codec->width
1183
          || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1184

    
1185
            /* initialize a new scaler context */
1186
            sws_freeContext(ost->img_resample_ctx);
1187
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1188
            ost->img_resample_ctx = sws_getContext(
1189
                ist->st->codec->width,
1190
                ist->st->codec->height,
1191
                ist->st->codec->pix_fmt,
1192
                ost->st->codec->width,
1193
                ost->st->codec->height,
1194
                ost->st->codec->pix_fmt,
1195
                sws_flags, NULL, NULL, NULL);
1196
            if (ost->img_resample_ctx == NULL) {
1197
                fprintf(stderr, "Cannot get resampling context\n");
1198
                ffmpeg_exit(1);
1199
            }
1200
        }
1201
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1202
              0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1203
    }
1204
#endif
1205

    
1206
    /* duplicates frame if needed */
1207
    for(i=0;i<nb_frames;i++) {
1208
        AVPacket pkt;
1209
        av_init_packet(&pkt);
1210
        pkt.stream_index= ost->index;
1211

    
1212
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1213
            /* raw pictures are written as AVPicture structure to
1214
               avoid any copies. We support temorarily the older
1215
               method. */
1216
            AVFrame* old_frame = enc->coded_frame;
1217
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1218
            pkt.data= (uint8_t *)final_picture;
1219
            pkt.size=  sizeof(AVPicture);
1220
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1221
            pkt.flags |= AV_PKT_FLAG_KEY;
1222

    
1223
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1224
            enc->coded_frame = old_frame;
1225
        } else {
1226
            AVFrame big_picture;
1227

    
1228
            big_picture= *final_picture;
1229
            /* better than nothing: use input picture interlaced
1230
               settings */
1231
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1232
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1233
                if(top_field_first == -1)
1234
                    big_picture.top_field_first = in_picture->top_field_first;
1235
                else
1236
                    big_picture.top_field_first = top_field_first;
1237
            }
1238

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

    
1261
            if(ret>0){
1262
                pkt.data= bit_buffer;
1263
                pkt.size= ret;
1264
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1265
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1266
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1267
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1268
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1269

    
1270
                if(enc->coded_frame->key_frame)
1271
                    pkt.flags |= AV_PKT_FLAG_KEY;
1272
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1273
                *frame_size = ret;
1274
                video_size += ret;
1275
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1276
                //        enc->frame_number-1, ret, enc->pict_type);
1277
                /* if two pass, output log */
1278
                if (ost->logfile && enc->stats_out) {
1279
                    fprintf(ost->logfile, "%s", enc->stats_out);
1280
                }
1281
            }
1282
        }
1283
        ost->sync_opts++;
1284
        ost->frame_number++;
1285
    }
1286
}
1287

    
1288
static double psnr(double d){
1289
    return -10.0*log(d)/log(10.0);
1290
}
1291

    
1292
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1293
                           int frame_size)
1294
{
1295
    AVCodecContext *enc;
1296
    int frame_number;
1297
    double ti1, bitrate, avg_bitrate;
1298

    
1299
    /* this is executed just the first time do_video_stats is called */
1300
    if (!vstats_file) {
1301
        vstats_file = fopen(vstats_filename, "w");
1302
        if (!vstats_file) {
1303
            perror("fopen");
1304
            ffmpeg_exit(1);
1305
        }
1306
    }
1307

    
1308
    enc = ost->st->codec;
1309
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1310
        frame_number = ost->frame_number;
1311
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1312
        if (enc->flags&CODEC_FLAG_PSNR)
1313
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1314

    
1315
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1316
        /* compute pts value */
1317
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1318
        if (ti1 < 0.01)
1319
            ti1 = 0.01;
1320

    
1321
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1322
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1323
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1324
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1325
        fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1326
    }
1327
}
1328

    
1329
static void print_report(AVFormatContext **output_files,
1330
                         AVOutputStream **ost_table, int nb_ostreams,
1331
                         int is_last_report)
1332
{
1333
    char buf[1024];
1334
    AVOutputStream *ost;
1335
    AVFormatContext *oc;
1336
    int64_t total_size;
1337
    AVCodecContext *enc;
1338
    int frame_number, vid, i;
1339
    double bitrate, ti1, pts;
1340
    static int64_t last_time = -1;
1341
    static int qp_histogram[52];
1342

    
1343
    if (!is_last_report) {
1344
        int64_t cur_time;
1345
        /* display the report every 0.5 seconds */
1346
        cur_time = av_gettime();
1347
        if (last_time == -1) {
1348
            last_time = cur_time;
1349
            return;
1350
        }
1351
        if ((cur_time - last_time) < 500000)
1352
            return;
1353
        last_time = cur_time;
1354
    }
1355

    
1356

    
1357
    oc = output_files[0];
1358

    
1359
    total_size = url_fsize(oc->pb);
1360
    if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1361
        total_size= url_ftell(oc->pb);
1362

    
1363
    buf[0] = '\0';
1364
    ti1 = 1e10;
1365
    vid = 0;
1366
    for(i=0;i<nb_ostreams;i++) {
1367
        ost = ost_table[i];
1368
        enc = ost->st->codec;
1369
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1370
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1371
                     !ost->st->stream_copy ?
1372
                     enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1373
        }
1374
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1375
            float t = (av_gettime()-timer_start) / 1000000.0;
1376

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

    
1423
    if (verbose || is_last_report) {
1424
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1425

    
1426
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1427
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1428
            (double)total_size / 1024, ti1, bitrate);
1429

    
1430
        if (nb_frames_dup || nb_frames_drop)
1431
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1432
                  nb_frames_dup, nb_frames_drop);
1433

    
1434
        if (verbose >= 0)
1435
            fprintf(stderr, "%s    \r", buf);
1436

    
1437
        fflush(stderr);
1438
    }
1439

    
1440
    if (is_last_report && verbose >= 0){
1441
        int64_t raw= audio_size + video_size + extra_size;
1442
        fprintf(stderr, "\n");
1443
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1444
                video_size/1024.0,
1445
                audio_size/1024.0,
1446
                extra_size/1024.0,
1447
                100.0*(total_size - raw)/raw
1448
        );
1449
    }
1450
}
1451

    
1452
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1453
static int output_packet(AVInputStream *ist, int ist_index,
1454
                         AVOutputStream **ost_table, int nb_ostreams,
1455
                         const AVPacket *pkt)
1456
{
1457
    AVFormatContext *os;
1458
    AVOutputStream *ost;
1459
    int ret, i;
1460
    int got_picture;
1461
    AVFrame picture;
1462
    void *buffer_to_free;
1463
    static unsigned int samples_size= 0;
1464
    AVSubtitle subtitle, *subtitle_to_free;
1465
    int64_t pkt_pts = AV_NOPTS_VALUE;
1466
#if CONFIG_AVFILTER
1467
    int frame_available;
1468
#endif
1469

    
1470
    AVPacket avpkt;
1471
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1472

    
1473
    if(ist->next_pts == AV_NOPTS_VALUE)
1474
        ist->next_pts= ist->pts;
1475

    
1476
    if (pkt == NULL) {
1477
        /* EOF handling */
1478
        av_init_packet(&avpkt);
1479
        avpkt.data = NULL;
1480
        avpkt.size = 0;
1481
        goto handle_eof;
1482
    } else {
1483
        avpkt = *pkt;
1484
    }
1485

    
1486
    if(pkt->dts != AV_NOPTS_VALUE)
1487
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1488
    if(pkt->pts != AV_NOPTS_VALUE)
1489
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1490

    
1491
    //while we have more to decode or while the decoder did output something on EOF
1492
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1493
        uint8_t *data_buf, *decoded_data_buf;
1494
        int data_size, decoded_data_size;
1495
    handle_eof:
1496
        ist->pts= ist->next_pts;
1497

    
1498
        if(avpkt.size && avpkt.size != pkt->size &&
1499
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1500
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1501
            ist->showed_multi_packet_warning=1;
1502
        }
1503

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

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

    
1597
        buffer_to_free = NULL;
1598
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1599
            pre_process_video_frame(ist, (AVPicture *)&picture,
1600
                                    &buffer_to_free);
1601
        }
1602

    
1603
#if CONFIG_AVFILTER
1604
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1605
            AVRational sar;
1606
            if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1607
            else                                  sar = ist->st->codec->sample_aspect_ratio;
1608
            // add it to be filtered
1609
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1610
                                     ist->pts,
1611
                                     sar);
1612
        }
1613
#endif
1614

    
1615
        // preprocess audio (volume)
1616
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1617
            if (audio_volume != 256) {
1618
                short *volp;
1619
                volp = samples;
1620
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1621
                    int v = ((*volp) * audio_volume + 128) >> 8;
1622
                    if (v < -32768) v = -32768;
1623
                    if (v >  32767) v = 32767;
1624
                    *volp++ = v;
1625
                }
1626
            }
1627
        }
1628

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

    
1654
                ost = ost_table[i];
1655
                if (ost->source_index == ist_index) {
1656
                    os = output_files[ost->file_index];
1657

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

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

    
1688
                        av_init_packet(&opkt);
1689

    
1690
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1691
                            continue;
1692

    
1693
                        /* no reencoding needed : output the packet directly */
1694
                        /* force the input stream PTS */
1695

    
1696
                        avcodec_get_frame_defaults(&avframe);
1697
                        ost->st->codec->coded_frame= &avframe;
1698
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1699

    
1700
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1701
                            audio_size += data_size;
1702
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1703
                            video_size += data_size;
1704
                            ost->sync_opts++;
1705
                        }
1706

    
1707
                        opkt.stream_index= ost->index;
1708
                        if(pkt->pts != AV_NOPTS_VALUE)
1709
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1710
                        else
1711
                            opkt.pts= AV_NOPTS_VALUE;
1712

    
1713
                        if (pkt->dts == AV_NOPTS_VALUE)
1714
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1715
                        else
1716
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1717
                        opkt.dts -= ost_tb_start_time;
1718

    
1719
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1720
                        opkt.flags= pkt->flags;
1721

    
1722
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1723
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1724
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1725
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1726
                           ) {
1727
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1728
                                opkt.destruct= av_destruct_packet;
1729
                        } else {
1730
                            opkt.data = data_buf;
1731
                            opkt.size = data_size;
1732
                        }
1733

    
1734
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1735
                        ost->st->codec->frame_number++;
1736
                        ost->frame_number++;
1737
                        av_free_packet(&opkt);
1738
                    }
1739
                }
1740
            }
1741

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

    
1760
        for(i=0;i<nb_ostreams;i++) {
1761
            ost = ost_table[i];
1762
            if (ost->source_index == ist_index) {
1763
                AVCodecContext *enc= ost->st->codec;
1764
                os = output_files[ost->file_index];
1765

    
1766
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1767
                    continue;
1768
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1769
                    continue;
1770

    
1771
                if (ost->encoding_needed) {
1772
                    for(;;) {
1773
                        AVPacket pkt;
1774
                        int fifo_bytes;
1775
                        av_init_packet(&pkt);
1776
                        pkt.stream_index= ost->index;
1777

    
1778
                        switch(ost->st->codec->codec_type) {
1779
                        case AVMEDIA_TYPE_AUDIO:
1780
                            fifo_bytes = av_fifo_size(ost->fifo);
1781
                            ret = 0;
1782
                            /* encode any samples remaining in fifo */
1783
                            if (fifo_bytes > 0) {
1784
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1785
                                int fs_tmp = enc->frame_size;
1786

    
1787
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1788
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1789
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1790
                                } else { /* pad */
1791
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1792
                                    if (allocated_audio_buf_size < frame_bytes)
1793
                                        ffmpeg_exit(1);
1794
                                    memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes);
1795
                                }
1796

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

    
1829
                        if(ret<=0)
1830
                            break;
1831
                        pkt.data= bit_buffer;
1832
                        pkt.size= ret;
1833
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1834
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1835
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1836
                    }
1837
                }
1838
            }
1839
        }
1840
    }
1841

    
1842
    return 0;
1843
 fail_decode:
1844
    return -1;
1845
}
1846

    
1847
static void print_sdp(AVFormatContext **avc, int n)
1848
{
1849
    char sdp[2048];
1850

    
1851
    avf_sdp_create(avc, n, sdp, sizeof(sdp));
1852
    printf("SDP:\n%s\n", sdp);
1853
    fflush(stdout);
1854
}
1855

    
1856
static int copy_chapters(int infile, int outfile)
1857
{
1858
    AVFormatContext *is = input_files[infile];
1859
    AVFormatContext *os = output_files[outfile];
1860
    int i;
1861

    
1862
    for (i = 0; i < is->nb_chapters; i++) {
1863
        AVChapter *in_ch = is->chapters[i], *out_ch;
1864
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1865
                                      AV_TIME_BASE_Q, in_ch->time_base);
1866
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1867
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1868

    
1869

    
1870
        if (in_ch->end < ts_off)
1871
            continue;
1872
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1873
            break;
1874

    
1875
        out_ch = av_mallocz(sizeof(AVChapter));
1876
        if (!out_ch)
1877
            return AVERROR(ENOMEM);
1878

    
1879
        out_ch->id        = in_ch->id;
1880
        out_ch->time_base = in_ch->time_base;
1881
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1882
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1883

    
1884
        if (metadata_chapters_autocopy)
1885
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1886

    
1887
        os->nb_chapters++;
1888
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1889
        if (!os->chapters)
1890
            return AVERROR(ENOMEM);
1891
        os->chapters[os->nb_chapters - 1] = out_ch;
1892
    }
1893
    return 0;
1894
}
1895

    
1896
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1897
                                    AVCodecContext *avctx)
1898
{
1899
    char *p;
1900
    int n = 1, i;
1901
    int64_t t;
1902

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

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

    
1940
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1941
    if (!file_table)
1942
        goto fail;
1943

    
1944
    /* input stream init */
1945
    j = 0;
1946
    for(i=0;i<nb_input_files;i++) {
1947
        is = input_files[i];
1948
        file_table[i].ist_index = j;
1949
        file_table[i].nb_streams = is->nb_streams;
1950
        j += is->nb_streams;
1951
    }
1952
    nb_istreams = j;
1953

    
1954
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1955
    if (!ist_table)
1956
        goto fail;
1957

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

    
1975
            if (rate_emu) {
1976
                ist->start = av_gettime();
1977
            }
1978
        }
1979
    }
1980

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

    
1999
    /* Sanity check the mapping args -- do the input files & streams exist? */
2000
    for(i=0;i<nb_stream_maps;i++) {
2001
        int fi = stream_maps[i].file_index;
2002
        int si = stream_maps[i].stream_index;
2003

    
2004
        if (fi < 0 || fi > nb_input_files - 1 ||
2005
            si < 0 || si > file_table[fi].nb_streams - 1) {
2006
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2007
            ret = AVERROR(EINVAL);
2008
            goto fail;
2009
        }
2010
        fi = stream_maps[i].sync_file_index;
2011
        si = stream_maps[i].sync_stream_index;
2012
        if (fi < 0 || fi > nb_input_files - 1 ||
2013
            si < 0 || si > file_table[fi].nb_streams - 1) {
2014
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2015
            ret = AVERROR(EINVAL);
2016
            goto fail;
2017
        }
2018
    }
2019

    
2020
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2021
    if (!ost_table)
2022
        goto fail;
2023
    n = 0;
2024
    for(k=0;k<nb_output_files;k++) {
2025
        os = output_files[k];
2026
        for(i=0;i<os->nb_streams;i++,n++) {
2027
            int found;
2028
            ost = ost_table[n] = output_streams_for_file[k][i];
2029
            ost->st = os->streams[i];
2030
            if (nb_stream_maps > 0) {
2031
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2032
                    stream_maps[n].stream_index;
2033

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

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

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

    
2103
    /* for each output stream, we compute the right encoding parameters */
2104
    for(i=0;i<nb_ostreams;i++) {
2105
        ost = ost_table[i];
2106
        os = output_files[ost->file_index];
2107
        ist = ist_table[ost->source_index];
2108

    
2109
        codec = ost->st->codec;
2110
        icodec = ist->st->codec;
2111

    
2112
        if (metadata_streams_autocopy)
2113
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2114
                             AV_METADATA_DONT_OVERWRITE);
2115

    
2116
        ost->st->disposition = ist->st->disposition;
2117
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2118
        codec->chroma_sample_location = icodec->chroma_sample_location;
2119

    
2120
        if (ost->st->stream_copy) {
2121
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2122

    
2123
            if (extra_size > INT_MAX)
2124
                goto fail;
2125

    
2126
            /* if stream_copy is selected, no need to decode or encode */
2127
            codec->codec_id = icodec->codec_id;
2128
            codec->codec_type = icodec->codec_type;
2129

    
2130
            if(!codec->codec_tag){
2131
                if(   !os->oformat->codec_tag
2132
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2133
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2134
                    codec->codec_tag = icodec->codec_tag;
2135
            }
2136

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

    
2226
                    ost->original_height = icodec->height;
2227
                    ost->original_width  = icodec->width;
2228
#endif
2229
                    codec->bits_per_raw_sample= 0;
2230
                }
2231
                ost->resample_height = icodec->height;
2232
                ost->resample_width  = icodec->width;
2233
                ost->resample_pix_fmt= icodec->pix_fmt;
2234
                ost->encoding_needed = 1;
2235
                ist->decoding_needed = 1;
2236

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

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

    
2285
    if (!bit_buffer)
2286
        bit_buffer = av_malloc(bit_buffer_size);
2287
    if (!bit_buffer) {
2288
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2289
                bit_buffer_size);
2290
        ret = AVERROR(ENOMEM);
2291
        goto fail;
2292
    }
2293

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

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

    
2351
    /* init pts */
2352
    for(i=0;i<nb_istreams;i++) {
2353
        AVStream *st;
2354
        ist = ist_table[i];
2355
        st= ist->st;
2356
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2357
        ist->next_pts = AV_NOPTS_VALUE;
2358
        init_pts_correction(&ist->pts_ctx);
2359
        ist->is_start = 1;
2360
    }
2361

    
2362
    /* set meta data information from input file if required */
2363
    for (i=0;i<nb_meta_data_maps;i++) {
2364
        AVFormatContext *files[2];
2365
        AVMetadata      **meta[2];
2366
        int j;
2367

    
2368
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2369
        if ((index) < 0 || (index) >= (nb_elems)) {\
2370
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2371
                     (desc), (index));\
2372
            ret = AVERROR(EINVAL);\
2373
            goto dump_format;\
2374
        }
2375

    
2376
        int out_file_index = meta_data_maps[i][0].file;
2377
        int in_file_index = meta_data_maps[i][1].file;
2378
        if (in_file_index < 0 || out_file_index < 0)
2379
            continue;
2380
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2381
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2382

    
2383
        files[0] = output_files[out_file_index];
2384
        files[1] = input_files[in_file_index];
2385

    
2386
        for (j = 0; j < 2; j++) {
2387
            AVMetaDataMap *map = &meta_data_maps[i][j];
2388

    
2389
            switch (map->type) {
2390
            case 'g':
2391
                meta[j] = &files[j]->metadata;
2392
                break;
2393
            case 's':
2394
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2395
                meta[j] = &files[j]->streams[map->index]->metadata;
2396
                break;
2397
            case 'c':
2398
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2399
                meta[j] = &files[j]->chapters[map->index]->metadata;
2400
                break;
2401
            case 'p':
2402
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2403
                meta[j] = &files[j]->programs[map->index]->metadata;
2404
                break;
2405
            }
2406
        }
2407

    
2408
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2409
    }
2410

    
2411
    /* copy global metadata by default */
2412
    if (metadata_global_autocopy) {
2413

    
2414
        for (i = 0; i < nb_output_files; i++)
2415
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2416
                             AV_METADATA_DONT_OVERWRITE);
2417
    }
2418

    
2419
    /* copy chapters according to chapter maps */
2420
    for (i = 0; i < nb_chapter_maps; i++) {
2421
        int infile  = chapter_maps[i].in_file;
2422
        int outfile = chapter_maps[i].out_file;
2423

    
2424
        if (infile < 0 || outfile < 0)
2425
            continue;
2426
        if (infile >= nb_input_files) {
2427
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2428
            ret = AVERROR(EINVAL);
2429
            goto dump_format;
2430
        }
2431
        if (outfile >= nb_output_files) {
2432
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2433
            ret = AVERROR(EINVAL);
2434
            goto dump_format;
2435
        }
2436
        copy_chapters(infile, outfile);
2437
    }
2438

    
2439
    /* copy chapters from the first input file that has them*/
2440
    if (!nb_chapter_maps)
2441
        for (i = 0; i < nb_input_files; i++) {
2442
            if (!input_files[i]->nb_chapters)
2443
                continue;
2444

    
2445
            for (j = 0; j < nb_output_files; j++)
2446
                if ((ret = copy_chapters(i, j)) < 0)
2447
                    goto dump_format;
2448
            break;
2449
        }
2450

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

    
2464
 dump_format:
2465
    /* dump the file output parameters - cannot be done before in case
2466
       of stream copy */
2467
    for(i=0;i<nb_output_files;i++) {
2468
        dump_format(output_files[i], i, output_files[i]->filename, 1);
2469
    }
2470

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

    
2489
    if (ret) {
2490
        fprintf(stderr, "%s\n", error);
2491
        goto fail;
2492
    }
2493

    
2494
    if (want_sdp) {
2495
        print_sdp(output_files, nb_output_files);
2496
    }
2497

    
2498
    if (!using_stdin && verbose >= 0) {
2499
        fprintf(stderr, "Press [q] to stop encoding\n");
2500
        url_set_interrupt_cb(decode_interrupt_cb);
2501
    }
2502
    term_init();
2503

    
2504
    timer_start = av_gettime();
2505

    
2506
    for(; received_sigterm == 0;) {
2507
        int file_index, ist_index;
2508
        AVPacket pkt;
2509
        double ipts_min;
2510
        double opts_min;
2511

    
2512
    redo:
2513
        ipts_min= 1e100;
2514
        opts_min= 1e100;
2515
        /* if 'q' pressed, exits */
2516
        if (!using_stdin) {
2517
            if (q_pressed)
2518
                break;
2519
            /* read_key() returns 0 on EOF */
2520
            key = read_key();
2521
            if (key == 'q')
2522
                break;
2523
        }
2524

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

    
2563
        /* finish if limit size exhausted */
2564
        if (limit_filesize != 0 && limit_filesize <= url_ftell(output_files[0]->pb))
2565
            break;
2566

    
2567
        /* read a frame from it and output it in the fifo */
2568
        is = input_files[file_index];
2569
        ret= av_read_frame(is, &pkt);
2570
        if(ret == AVERROR(EAGAIN)){
2571
            no_packet[file_index]=1;
2572
            no_packet_count++;
2573
            continue;
2574
        }
2575
        if (ret < 0) {
2576
            file_table[file_index].eof_reached = 1;
2577
            if (opt_shortest)
2578
                break;
2579
            else
2580
                continue;
2581
        }
2582

    
2583
        no_packet_count=0;
2584
        memset(no_packet, 0, sizeof(no_packet));
2585

    
2586
        if (do_pkt_dump) {
2587
            av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2588
        }
2589
        /* the following test is needed in case new streams appear
2590
           dynamically in stream : we ignore them */
2591
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2592
            goto discard_packet;
2593
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2594
        ist = ist_table[ist_index];
2595
        if (ist->discard)
2596
            goto discard_packet;
2597

    
2598
        if (pkt.dts != AV_NOPTS_VALUE)
2599
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2600
        if (pkt.pts != AV_NOPTS_VALUE)
2601
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2602

    
2603
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2604
            && input_files_ts_scale[file_index][pkt.stream_index]){
2605
            if(pkt.pts != AV_NOPTS_VALUE)
2606
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2607
            if(pkt.dts != AV_NOPTS_VALUE)
2608
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2609
        }
2610

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

    
2626
        /* finish if recording time exhausted */
2627
        if (recording_time != INT64_MAX &&
2628
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2629
            ist->is_past_recording_time = 1;
2630
            goto discard_packet;
2631
        }
2632

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

    
2636
            if (verbose >= 0)
2637
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2638
                        ist->file_index, ist->index);
2639
            if (exit_on_error)
2640
                ffmpeg_exit(1);
2641
            av_free_packet(&pkt);
2642
            goto redo;
2643
        }
2644

    
2645
    discard_packet:
2646
        av_free_packet(&pkt);
2647

    
2648
        /* dump report by using the output first video and audio streams */
2649
        print_report(output_files, ost_table, nb_ostreams, 0);
2650
    }
2651

    
2652
    /* at the end of stream, we must flush the decoder buffers */
2653
    for(i=0;i<nb_istreams;i++) {
2654
        ist = ist_table[i];
2655
        if (ist->decoding_needed) {
2656
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2657
        }
2658
    }
2659

    
2660
    term_exit();
2661

    
2662
    /* write the trailer if needed and close file */
2663
    for(i=0;i<nb_output_files;i++) {
2664
        os = output_files[i];
2665
        av_write_trailer(os);
2666
    }
2667

    
2668
    /* dump report by using the first video and audio streams */
2669
    print_report(output_files, ost_table, nb_ostreams, 1);
2670

    
2671
    /* close each encoder */
2672
    for(i=0;i<nb_ostreams;i++) {
2673
        ost = ost_table[i];
2674
        if (ost->encoding_needed) {
2675
            av_freep(&ost->st->codec->stats_in);
2676
            avcodec_close(ost->st->codec);
2677
        }
2678
    }
2679

    
2680
    /* close each decoder */
2681
    for(i=0;i<nb_istreams;i++) {
2682
        ist = ist_table[i];
2683
        if (ist->decoding_needed) {
2684
            avcodec_close(ist->st->codec);
2685
        }
2686
    }
2687
#if CONFIG_AVFILTER
2688
    avfilter_graph_free(&graph);
2689
#endif
2690

    
2691
    /* finished ! */
2692
    ret = 0;
2693

    
2694
 fail:
2695
    av_freep(&bit_buffer);
2696
    av_free(file_table);
2697

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

    
2734
static void opt_format(const char *arg)
2735
{
2736
    last_asked_format = arg;
2737
}
2738

    
2739
static void opt_video_rc_override_string(const char *arg)
2740
{
2741
    video_rc_override_string = arg;
2742
}
2743

    
2744
static int opt_me_threshold(const char *opt, const char *arg)
2745
{
2746
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2747
    return 0;
2748
}
2749

    
2750
static int opt_verbose(const char *opt, const char *arg)
2751
{
2752
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2753
    return 0;
2754
}
2755

    
2756
static int opt_frame_rate(const char *opt, const char *arg)
2757
{
2758
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2759
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2760
        ffmpeg_exit(1);
2761
    }
2762
    return 0;
2763
}
2764

    
2765
static int opt_bitrate(const char *opt, const char *arg)
2766
{
2767
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2768

    
2769
    opt_default(opt, arg);
2770

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

    
2774
    return 0;
2775
}
2776

    
2777
static int opt_frame_crop(const char *opt, const char *arg)
2778
{
2779
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2780
    return AVERROR(EINVAL);
2781
}
2782

    
2783
static void opt_frame_size(const char *arg)
2784
{
2785
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2786
        fprintf(stderr, "Incorrect frame size\n");
2787
        ffmpeg_exit(1);
2788
    }
2789
}
2790

    
2791
static int opt_pad(const char *opt, const char *arg) {
2792
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2793
    return -1;
2794
}
2795

    
2796
static void opt_frame_pix_fmt(const char *arg)
2797
{
2798
    if (strcmp(arg, "list")) {
2799
        frame_pix_fmt = av_get_pix_fmt(arg);
2800
        if (frame_pix_fmt == PIX_FMT_NONE) {
2801
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2802
            ffmpeg_exit(1);
2803
        }
2804
    } else {
2805
        show_pix_fmts();
2806
        ffmpeg_exit(0);
2807
    }
2808
}
2809

    
2810
static void opt_frame_aspect_ratio(const char *arg)
2811
{
2812
    int x = 0, y = 0;
2813
    double ar = 0;
2814
    const char *p;
2815
    char *end;
2816

    
2817
    p = strchr(arg, ':');
2818
    if (p) {
2819
        x = strtol(arg, &end, 10);
2820
        if (end == p)
2821
            y = strtol(end+1, &end, 10);
2822
        if (x > 0 && y > 0)
2823
            ar = (double)x / (double)y;
2824
    } else
2825
        ar = strtod(arg, NULL);
2826

    
2827
    if (!ar) {
2828
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2829
        ffmpeg_exit(1);
2830
    }
2831
    frame_aspect_ratio = ar;
2832
}
2833

    
2834
static int opt_metadata(const char *opt, const char *arg)
2835
{
2836
    char *mid= strchr(arg, '=');
2837

    
2838
    if(!mid){
2839
        fprintf(stderr, "Missing =\n");
2840
        ffmpeg_exit(1);
2841
    }
2842
    *mid++= 0;
2843

    
2844
    av_metadata_set2(&metadata, arg, mid, 0);
2845

    
2846
    return 0;
2847
}
2848

    
2849
static void opt_qscale(const char *arg)
2850
{
2851
    video_qscale = atof(arg);
2852
    if (video_qscale <= 0 ||
2853
        video_qscale > 255) {
2854
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2855
        ffmpeg_exit(1);
2856
    }
2857
}
2858

    
2859
static void opt_top_field_first(const char *arg)
2860
{
2861
    top_field_first= atoi(arg);
2862
}
2863

    
2864
static int opt_thread_count(const char *opt, const char *arg)
2865
{
2866
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2867
#if !HAVE_THREADS
2868
    if (verbose >= 0)
2869
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2870
#endif
2871
    return 0;
2872
}
2873

    
2874
static void opt_audio_sample_fmt(const char *arg)
2875
{
2876
    if (strcmp(arg, "list")) {
2877
        audio_sample_fmt = av_get_sample_fmt(arg);
2878
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2879
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2880
            ffmpeg_exit(1);
2881
        }
2882
    } else {
2883
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2884
        ffmpeg_exit(0);
2885
    }
2886
}
2887

    
2888
static int opt_audio_rate(const char *opt, const char *arg)
2889
{
2890
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2891
    return 0;
2892
}
2893

    
2894
static int opt_audio_channels(const char *opt, const char *arg)
2895
{
2896
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2897
    return 0;
2898
}
2899

    
2900
static void opt_video_channel(const char *arg)
2901
{
2902
    video_channel = strtol(arg, NULL, 0);
2903
}
2904

    
2905
static void opt_video_standard(const char *arg)
2906
{
2907
    video_standard = av_strdup(arg);
2908
}
2909

    
2910
static void opt_codec(int *pstream_copy, char **pcodec_name,
2911
                      int codec_type, const char *arg)
2912
{
2913
    av_freep(pcodec_name);
2914
    if (!strcmp(arg, "copy")) {
2915
        *pstream_copy = 1;
2916
    } else {
2917
        *pcodec_name = av_strdup(arg);
2918
    }
2919
}
2920

    
2921
static void opt_audio_codec(const char *arg)
2922
{
2923
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2924
}
2925

    
2926
static void opt_video_codec(const char *arg)
2927
{
2928
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2929
}
2930

    
2931
static void opt_subtitle_codec(const char *arg)
2932
{
2933
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2934
}
2935

    
2936
static int opt_codec_tag(const char *opt, const char *arg)
2937
{
2938
    char *tail;
2939
    uint32_t *codec_tag;
2940

    
2941
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2942
                !strcmp(opt, "vtag") ? &video_codec_tag :
2943
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2944
    if (!codec_tag)
2945
        return -1;
2946

    
2947
    *codec_tag = strtol(arg, &tail, 0);
2948
    if (!tail || *tail)
2949
        *codec_tag = AV_RL32(arg);
2950

    
2951
    return 0;
2952
}
2953

    
2954
static void opt_map(const char *arg)
2955
{
2956
    AVStreamMap *m;
2957
    char *p;
2958

    
2959
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2960
    m = &stream_maps[nb_stream_maps-1];
2961

    
2962
    m->file_index = strtol(arg, &p, 0);
2963
    if (*p)
2964
        p++;
2965

    
2966
    m->stream_index = strtol(p, &p, 0);
2967
    if (*p) {
2968
        p++;
2969
        m->sync_file_index = strtol(p, &p, 0);
2970
        if (*p)
2971
            p++;
2972
        m->sync_stream_index = strtol(p, &p, 0);
2973
    } else {
2974
        m->sync_file_index = m->file_index;
2975
        m->sync_stream_index = m->stream_index;
2976
    }
2977
}
2978

    
2979
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2980
{
2981
    *endptr = arg;
2982
    if (*arg == ',') {
2983
        *type = *(++arg);
2984
        switch (*arg) {
2985
        case 'g':
2986
            break;
2987
        case 's':
2988
        case 'c':
2989
        case 'p':
2990
            *index = strtol(++arg, endptr, 0);
2991
            break;
2992
        default:
2993
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2994
            ffmpeg_exit(1);
2995
        }
2996
    } else
2997
        *type = 'g';
2998
}
2999

    
3000
static void opt_map_metadata(const char *arg)
3001
{
3002
    AVMetaDataMap *m, *m1;
3003
    char *p;
3004

    
3005
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3006
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3007

    
3008
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3009
    m->file = strtol(arg, &p, 0);
3010
    parse_meta_type(p, &m->type, &m->index, &p);
3011
    if (*p)
3012
        p++;
3013

    
3014
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3015
    m1->file = strtol(p, &p, 0);
3016
    parse_meta_type(p, &m1->type, &m1->index, &p);
3017

    
3018
    if (m->type == 'g' || m1->type == 'g')
3019
        metadata_global_autocopy = 0;
3020
    if (m->type == 's' || m1->type == 's')
3021
        metadata_streams_autocopy = 0;
3022
    if (m->type == 'c' || m1->type == 'c')
3023
        metadata_chapters_autocopy = 0;
3024
}
3025

    
3026
static void opt_map_meta_data(const char *arg)
3027
{
3028
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3029
                    "Use -map_metadata instead.\n");
3030
    opt_map_metadata(arg);
3031
}
3032

    
3033
static void opt_map_chapters(const char *arg)
3034
{
3035
    AVChapterMap *c;
3036
    char *p;
3037

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

    
3045
    c->in_file = strtol(p, &p, 0);
3046
}
3047

    
3048
static void opt_input_ts_scale(const char *arg)
3049
{
3050
    unsigned int stream;
3051
    double scale;
3052
    char *p;
3053

    
3054
    stream = strtol(arg, &p, 0);
3055
    if (*p)
3056
        p++;
3057
    scale= strtod(p, &p);
3058

    
3059
    if(stream >= MAX_STREAMS)
3060
        ffmpeg_exit(1);
3061

    
3062
    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);
3063
    input_files_ts_scale[nb_input_files][stream]= scale;
3064
}
3065

    
3066
static int opt_recording_time(const char *opt, const char *arg)
3067
{
3068
    recording_time = parse_time_or_die(opt, arg, 1);
3069
    return 0;
3070
}
3071

    
3072
static int opt_start_time(const char *opt, const char *arg)
3073
{
3074
    start_time = parse_time_or_die(opt, arg, 1);
3075
    return 0;
3076
}
3077

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

    
3084
static int opt_input_ts_offset(const char *opt, const char *arg)
3085
{
3086
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3087
    return 0;
3088
}
3089

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

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

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

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

    
3140
    if (!strcmp(filename, "-"))
3141
        filename = "pipe:";
3142

    
3143
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3144
                    !strcmp(filename, "/dev/stdin");
3145

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

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

    
3166
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3167

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

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

    
3209
    ic->loop_input = loop_input;
3210

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

    
3220
    timestamp = start_time;
3221
    /* add the stream start time */
3222
    if (ic->start_time != AV_NOPTS_VALUE)
3223
        timestamp += ic->start_time;
3224

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

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

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

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

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

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

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

    
3320
    nb_input_files++;
3321

    
3322
    video_channel = 0;
3323

    
3324
    av_freep(&video_codec_name);
3325
    av_freep(&audio_codec_name);
3326
    av_freep(&subtitle_codec_name);
3327
}
3328

    
3329
static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3330
                                         int *has_subtitle_ptr)
3331
{
3332
    int has_video, has_audio, has_subtitle, i, j;
3333
    AVFormatContext *ic;
3334

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

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

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

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

    
3394
    avcodec_get_context_defaults3(st->codec, codec);
3395
    ost->bitstream_filters = video_bitstream_filters;
3396
    video_bitstream_filters= NULL;
3397

    
3398
    avcodec_thread_init(st->codec, thread_count);
3399

    
3400
    video_enc = st->codec;
3401

    
3402
    if(video_codec_tag)
3403
        video_enc->codec_tag= video_codec_tag;
3404

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

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

    
3425
        video_enc->codec_id = codec_id;
3426
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3427

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

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

    
3439
        choose_pixel_fmt(st, codec);
3440

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

    
3449
        if(intra_matrix)
3450
            video_enc->intra_matrix = intra_matrix;
3451
        if(inter_matrix)
3452
            video_enc->inter_matrix = inter_matrix;
3453

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

    
3484
        if (do_psnr)
3485
            video_enc->flags|= CODEC_FLAG_PSNR;
3486

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

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

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

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

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

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

    
3540
    avcodec_get_context_defaults3(st->codec, codec);
3541

    
3542
    ost->bitstream_filters = audio_bitstream_filters;
3543
    audio_bitstream_filters= NULL;
3544

    
3545
    avcodec_thread_init(st->codec, thread_count);
3546

    
3547
    audio_enc = st->codec;
3548
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3549

    
3550
    if(audio_codec_tag)
3551
        audio_enc->codec_tag= audio_codec_tag;
3552

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

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

    
3584
    /* reset some key parameters */
3585
    audio_disable = 0;
3586
    av_freep(&audio_codec_name);
3587
    audio_stream_copy = 0;
3588
}
3589

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

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

    
3618
    ost->bitstream_filters = subtitle_bitstream_filters;
3619
    subtitle_bitstream_filters= NULL;
3620

    
3621
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3622

    
3623
    if(subtitle_codec_tag)
3624
        subtitle_enc->codec_tag= subtitle_codec_tag;
3625

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

    
3637
    if (subtitle_language) {
3638
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3639
        av_freep(&subtitle_language);
3640
    }
3641

    
3642
    subtitle_disable = 0;
3643
    av_freep(&subtitle_codec_name);
3644
    subtitle_stream_copy = 0;
3645
}
3646

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

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

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

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

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

    
3695
    if (!strcmp(filename, "-"))
3696
        filename = "pipe:";
3697

    
3698
    oc = avformat_alloc_context();
3699
    if (!oc) {
3700
        print_error(filename, AVERROR(ENOMEM));
3701
        ffmpeg_exit(1);
3702
    }
3703

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

    
3720
    oc->oformat = file_oformat;
3721
    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3722

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

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

    
3750
        /* manual disable */
3751
        if (audio_disable)    use_audio    = 0;
3752
        if (video_disable)    use_video    = 0;
3753
        if (subtitle_disable) use_subtitle = 0;
3754

    
3755
        if (use_video)    new_video_stream(oc, nb_output_files);
3756
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3757
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3758

    
3759
        oc->timestamp = recording_timestamp;
3760

    
3761
        av_metadata_copy(&oc->metadata, metadata, 0);
3762
        av_metadata_free(&metadata);
3763
    }
3764

    
3765
    output_files[nb_output_files++] = oc;
3766

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

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

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

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

    
3811
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3812
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3813
    oc->loop_output = loop_output;
3814
    oc->flags |= AVFMT_FLAG_NONBLOCK;
3815

    
3816
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3817

    
3818
    av_freep(&forced_key_frames);
3819
}
3820

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

    
3833
static int64_t getutime(void)
3834
{
3835
#if HAVE_GETRUSAGE
3836
    struct rusage rusage;
3837

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

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

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

    
3886
static void opt_inter_matrix(const char *arg)
3887
{
3888
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3889
    parse_matrix_coeffs(inter_matrix, arg);
3890
}
3891

    
3892
static void opt_intra_matrix(const char *arg)
3893
{
3894
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3895
    parse_matrix_coeffs(intra_matrix, arg);
3896
}
3897

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

    
3905
static void show_help(void)
3906
{
3907
    AVCodec *c;
3908
    AVOutputFormat *oformat = NULL;
3909

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

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

    
3948
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3949
    printf("\n");
3950

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

    
3959
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3960
}
3961

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

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

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

    
4018
    if(!strcmp(arg, "vcd")) {
4019

    
4020
        opt_video_codec("mpeg1video");
4021
        opt_audio_codec("mp2");
4022
        opt_format("vcd");
4023

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

    
4028
        opt_default("b", "1150000");
4029
        opt_default("maxrate", "1150000");
4030
        opt_default("minrate", "1150000");
4031
        opt_default("bufsize", "327680"); // 40*1024*8;
4032

    
4033
        opt_default("ab", "224000");
4034
        audio_sample_rate = 44100;
4035
        audio_channels = 2;
4036

    
4037
        opt_default("packetsize", "2324");
4038
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4039

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

    
4048
        opt_video_codec("mpeg2video");
4049
        opt_audio_codec("mp2");
4050
        opt_format("svcd");
4051

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

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

    
4062

    
4063
        opt_default("ab", "224000");
4064
        audio_sample_rate = 44100;
4065

    
4066
        opt_default("packetsize", "2324");
4067

    
4068
    } else if(!strcmp(arg, "dvd")) {
4069

    
4070
        opt_video_codec("mpeg2video");
4071
        opt_audio_codec("ac3");
4072
        opt_format("dvd");
4073

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

    
4078
        opt_default("b", "6000000");
4079
        opt_default("maxrate", "9000000");
4080
        opt_default("minrate", "0"); //1500000;
4081
        opt_default("bufsize", "1835008"); //224*1024*8;
4082

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

    
4086
        opt_default("ab", "448000");
4087
        audio_sample_rate = 48000;
4088

    
4089
    } else if(!strncmp(arg, "dv", 2)) {
4090

    
4091
        opt_format("dv");
4092

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

    
4098
        audio_sample_rate = 48000;
4099
        audio_channels = 2;
4100

    
4101
    } else {
4102
        fprintf(stderr, "Unknown target: %s\n", arg);
4103
        ffmpeg_exit(1);
4104
    }
4105
}
4106

    
4107
static void opt_vstats_file (const char *arg)
4108
{
4109
    av_free (vstats_filename);
4110
    vstats_filename=av_strdup (arg);
4111
}
4112

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

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

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

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

    
4134
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4135
          *opt == 'a' ? &audio_bitstream_filters :
4136
                        &subtitle_bitstream_filters;
4137
    while(*bsfp)
4138
        bsfp= &(*bsfp)->next;
4139

    
4140
    *bsfp= bsfc;
4141

    
4142
    return 0;
4143
}
4144

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

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

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

    
4179
    fclose(f);
4180

    
4181
    return 0;
4182
}
4183

    
4184
static const OptionDef options[] = {
4185
    /* main options */
4186
#include "cmdutils_common_opts.h"
4187
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4188
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4189
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4190
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4191
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4192
      "outfile[,metadata]:infile[,metadata]" },
4193
    { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4194
      "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
}