Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ b22dbb29

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
                    ist->st->codec->reordered_opaque = pkt_pts;
1543
                    pkt_pts = AV_NOPTS_VALUE;
1544

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

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

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

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

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

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

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

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

    
1687
                        av_init_packet(&opkt);
1688

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1868

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2503
    timer_start = av_gettime();
2504

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2644
    discard_packet:
2645
        av_free_packet(&pkt);
2646

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

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

    
2659
    term_exit();
2660

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2768
    opt_default(opt, arg);
2769

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

    
2773
    return 0;
2774
}
2775

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

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

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

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

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

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

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

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

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

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

    
2845
    return 0;
2846
}
2847

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2950
    return 0;
2951
}
2952

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3208
    ic->loop_input = loop_input;
3209

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

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

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

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

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

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

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

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

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

    
3319
    nb_input_files++;
3320

    
3321
    video_channel = 0;
3322

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

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

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

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

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

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

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

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

    
3399
    video_enc = st->codec;
3400

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

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

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

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

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

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

    
3438
        choose_pixel_fmt(st, codec);
3439

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3620
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3621

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3758
        oc->timestamp = recording_timestamp;
3759

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

    
3764
    output_files[nb_output_files++] = oc;
3765

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

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

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

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

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

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

    
3817
    av_freep(&forced_key_frames);
3818
}
3819

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4061

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

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

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

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

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

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

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

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

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

    
4090
        opt_format("dv");
4091

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

    
4097
        audio_sample_rate = 48000;
4098
        audio_channels = 2;
4099

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

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

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

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

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

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

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

    
4139
    *bsfp= bsfc;
4140

    
4141
    return 0;
4142
}
4143

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

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

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

    
4178
    fclose(f);
4179

    
4180
    return 0;
4181
}
4182

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

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

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

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

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

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

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

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

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

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

    
4323
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4324

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

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

    
4339
    init_opts();
4340

    
4341
    show_banner();
4342

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

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

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

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

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

    
4373
    return ffmpeg_exit(0);
4374
}