Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 4618637a

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
AVFilterGraph *graph = NULL;
176
#endif
177

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

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

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

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

    
223
static int rate_emu = 0;
224

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

    
228
static int audio_volume = 256;
229

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

    
245
static float dts_delta_threshold = 10;
246

    
247
static unsigned int sws_flags = SWS_BICUBIC;
248

    
249
static int64_t timer_start;
250

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

    
255
static short *samples;
256

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

    
261
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
262

    
263
struct AVInputStream;
264

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

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

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

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

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

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

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

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

    
342
#if HAVE_TERMIOS_H
343

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

    
348
#if CONFIG_AVFILTER
349

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

    
360
    graph = avfilter_graph_alloc();
361

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

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

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

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

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

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

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

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

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

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

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

    
430
static volatile int received_sigterm = 0;
431

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
551
    av_free(video_standard);
552

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

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

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

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

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

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

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

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

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

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

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

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

    
683
        s->nb_streams++;
684

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

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

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

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

    
717
        new_output_stream(s, nb_output_files);
718
    }
719

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

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

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

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

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

    
756
        bsfc= bsfc->next;
757
    }
758

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

    
766
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
767

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

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

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

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

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

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

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

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

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

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

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

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

    
886
                    if(byte_delta > allocated_for_size - size){
887
                        allocated_for_size= byte_delta + (int64_t)size;
888
                        goto need_realloc;
889
                    }
890
                    ist->is_start=0;
891

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

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

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

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

    
948
        frame_bytes = enc->frame_size * osize * enc->channels;
949

    
950
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
951
            AVPacket pkt;
952
            av_init_packet(&pkt);
953

    
954
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
955

    
956
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
957

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

    
973
            ost->sync_opts += enc->frame_size;
974
        }
975
    } else {
976
        AVPacket pkt;
977
        av_init_packet(&pkt);
978

    
979
        ost->sync_opts += size_out / (osize * enc->channels);
980

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

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

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

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

    
1017
    dec = ist->st->codec;
1018

    
1019
    /* deinterlace : must be done before any resize */
1020
    if (do_deinterlace) {
1021
        int size;
1022

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

    
1029
        picture2 = &picture_tmp;
1030
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1031

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

    
1044
    if (picture != picture2)
1045
        *picture = *picture2;
1046
    *bufp = buf;
1047
}
1048

    
1049
/* we begin to correct av delay at this threshold */
1050
#define AV_DELAY_MAX 0.100
1051

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

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

    
1071
    enc = ost->st->codec;
1072

    
1073
    if (!subtitle_out) {
1074
        subtitle_out = av_malloc(subtitle_out_max_size);
1075
    }
1076

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

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

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

    
1115
static int bit_buffer_size= 1024*256;
1116
static uint8_t *bit_buffer= NULL;
1117

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

    
1129
    enc = ost->st->codec;
1130
    dec = ist->st->codec;
1131

    
1132
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1133

    
1134
    /* by default, we output a single frame */
1135
    nb_frames = 1;
1136

    
1137
    *frame_size = 0;
1138

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

    
1164
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1165
    if (nb_frames <= 0)
1166
        return;
1167

    
1168
    formatted_picture = in_picture;
1169
    final_picture = formatted_picture;
1170
    padding_src = formatted_picture;
1171
    resampling_dst = &ost->pict_tmp;
1172

    
1173
    if (   ost->resample_height != ist->st->codec->height
1174
        || ost->resample_width  != ist->st->codec->width
1175
        || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
1176

    
1177
        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));
1178
        if(!ost->video_resample)
1179
            ffmpeg_exit(1);
1180
    }
1181

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

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

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

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

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

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

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

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

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

    
1293
static double psnr(double d){
1294
    return -10.0*log(d)/log(10.0);
1295
}
1296

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

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

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

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

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

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

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

    
1361

    
1362
    oc = output_files[0];
1363

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

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

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

    
1428
    if (verbose || is_last_report) {
1429
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1430

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

    
1435
        if (nb_frames_dup || nb_frames_drop)
1436
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1437
                  nb_frames_dup, nb_frames_drop);
1438

    
1439
        if (verbose >= 0)
1440
            fprintf(stderr, "%s    \r", buf);
1441

    
1442
        fflush(stderr);
1443
    }
1444

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

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

    
1475
    AVPacket avpkt;
1476
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1477

    
1478
    if(ist->next_pts == AV_NOPTS_VALUE)
1479
        ist->next_pts= ist->pts;
1480

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

    
1491
    if(pkt->dts != AV_NOPTS_VALUE)
1492
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1493
    if(pkt->pts != AV_NOPTS_VALUE)
1494
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1495

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

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

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

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

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

    
1607
#if CONFIG_AVFILTER
1608
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1609
            // add it to be filtered
1610
            av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1611
                                     ist->pts,
1612
                                     ist->st->codec->sample_aspect_ratio);
1613
        }
1614
#endif
1615

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

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

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

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

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

    
1689
                        av_init_packet(&opkt);
1690

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1871

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

    
1877
        out_ch = av_mallocz(sizeof(AVChapter));
1878
        if (!out_ch)
1879
            return AVERROR(ENOMEM);
1880

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

    
1886
        if (metadata_chapters_autocopy)
1887
            while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
1888
                av_metadata_set2(&out_ch->metadata, t->key, t->value, 0);
1889

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

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

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

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

    
1943
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1944
    if (!file_table)
1945
        goto fail;
1946

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

    
1957
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1958
    if (!ist_table)
1959
        goto fail;
1960

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

    
1978
            if (rate_emu) {
1979
                ist->start = av_gettime();
1980
            }
1981
        }
1982
    }
1983

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

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

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

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

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

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

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

    
2106
    /* for each output stream, we compute the right encoding parameters */
2107
    for(i=0;i<nb_ostreams;i++) {
2108
        AVMetadataTag *t = NULL;
2109
        ost = ost_table[i];
2110
        os = output_files[ost->file_index];
2111
        ist = ist_table[ost->source_index];
2112

    
2113
        codec = ost->st->codec;
2114
        icodec = ist->st->codec;
2115

    
2116
        if (metadata_streams_autocopy)
2117
            while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
2118
                av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2119
            }
2120

    
2121
        ost->st->disposition = ist->st->disposition;
2122
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2123
        codec->chroma_sample_location = icodec->chroma_sample_location;
2124

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

    
2128
            if (extra_size > INT_MAX)
2129
                goto fail;
2130

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2414
        mtag=NULL;
2415
        while((mtag=av_metadata_get(*meta[1], "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2416
            av_metadata_set2(meta[0], mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE);
2417
    }
2418

    
2419
    /* copy global metadata by default */
2420
    if (metadata_global_autocopy) {
2421
        AVMetadataTag *t = NULL;
2422

    
2423
        while ((t = av_metadata_get(input_files[0]->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
2424
            for (i = 0; i < nb_output_files; i++)
2425
                av_metadata_set2(&output_files[i]->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE);
2426
    }
2427

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

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

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

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

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

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

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

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

    
2503
    if (want_sdp) {
2504
        print_sdp(output_files, nb_output_files);
2505
    }
2506

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

    
2513
    timer_start = av_gettime();
2514

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

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

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

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

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

    
2592
        no_packet_count=0;
2593
        memset(no_packet, 0, sizeof(no_packet));
2594

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

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

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

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

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

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

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

    
2654
    discard_packet:
2655
        av_free_packet(&pkt);
2656

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

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

    
2669
    term_exit();
2670

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

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

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

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

    
2703
    /* finished ! */
2704
    ret = 0;
2705

    
2706
 fail:
2707
    av_freep(&bit_buffer);
2708
    av_free(file_table);
2709

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

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

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

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

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

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

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

    
2781
    opt_default(opt, arg);
2782

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

    
2786
    return 0;
2787
}
2788

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

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

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

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

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

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

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

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

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

    
2856
    av_metadata_set2(&metadata, arg, mid, 0);
2857

    
2858
    return 0;
2859
}
2860

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

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

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

    
2886
static void opt_audio_sample_fmt(const char *arg)
2887
{
2888
    if (strcmp(arg, "list"))
2889
        audio_sample_fmt = av_get_sample_fmt(arg);
2890
    else {
2891
        list_fmts(av_get_sample_fmt_string, AV_SAMPLE_FMT_NB);
2892
        ffmpeg_exit(0);
2893
    }
2894
}
2895

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

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

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

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

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

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

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

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

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

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

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

    
2959
    return 0;
2960
}
2961

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

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

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

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

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

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

    
3013
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3014
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3015

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3210
    ic->loop_input = loop_input;
3211

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

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

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

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

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

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

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

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

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

    
3321
    nb_input_files++;
3322

    
3323
    video_channel = 0;
3324

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

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

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

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

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

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

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

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

    
3401
    video_enc = st->codec;
3402

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

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

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

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

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

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

    
3440
        choose_pixel_fmt(st, codec);
3441

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3622
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3623

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
3761
        oc->timestamp = recording_timestamp;
3762

    
3763
        while ((tag = av_metadata_get(metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
3764
            av_metadata_set2(&oc->metadata, tag->key, tag->value, 0);
3765
        av_metadata_free(&metadata);
3766
    }
3767

    
3768
    output_files[nb_output_files++] = oc;
3769

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

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

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

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

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

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

    
3821
    nb_streamid_map = 0;
3822
    av_freep(&forced_key_frames);
3823
}
3824

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
4066

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

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

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

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

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

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

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

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

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

    
4095
        opt_format("dv");
4096

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

    
4102
        audio_sample_rate = 48000;
4103
        audio_channels = 2;
4104

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

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

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

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

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

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

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

    
4144
    *bsfp= bsfc;
4145

    
4146
    return 0;
4147
}
4148

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

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

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

    
4183
    fclose(f);
4184

    
4185
    return 0;
4186
}
4187

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

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

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

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

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

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

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

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

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

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

    
4324
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4325

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

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

    
4340
    init_opts();
4341

    
4342
    show_banner();
4343

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

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

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

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

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

    
4374
    return ffmpeg_exit(0);
4375
}