Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 70c24b21

History | View | Annotate | Download (165 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 "libavutil/opt.h"
38
#include "libavcodec/audioconvert.h"
39
#include "libavutil/audioconvert.h"
40
#include "libavutil/parseutils.h"
41
#include "libavutil/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
#include "libavformat/ffm.h" // not public API
51

    
52
#if CONFIG_AVFILTER
53
# include "libavfilter/avcodec.h"
54
# include "libavfilter/avfilter.h"
55
# include "libavfilter/avfiltergraph.h"
56
# include "libavfilter/vsrc_buffer.h"
57
#endif
58

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

    
71
#if HAVE_SYS_SELECT_H
72
#include <sys/select.h>
73
#endif
74

    
75
#if HAVE_TERMIOS_H
76
#include <fcntl.h>
77
#include <sys/ioctl.h>
78
#include <sys/time.h>
79
#include <termios.h>
80
#elif HAVE_KBHIT
81
#include <conio.h>
82
#endif
83
#include <time.h>
84

    
85
#include "cmdutils.h"
86

    
87
#include "libavutil/avassert.h"
88

    
89
const char program_name[] = "ffmpeg";
90
const int program_birth_year = 2000;
91

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

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

    
109
typedef struct AVChapterMap {
110
    int in_file;
111
    int out_file;
112
} AVChapterMap;
113

    
114
static const OptionDef options[];
115

    
116
#define MAX_FILES 100
117
#define MAX_STREAMS 1024    /* arbitrary sanity check value */
118

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

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

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

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

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

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

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

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

    
192
static int subtitle_disable = 0;
193
static char *subtitle_codec_name = NULL;
194
static char *subtitle_language = NULL;
195
static unsigned int subtitle_codec_tag = 0;
196

    
197
static int data_disable = 0;
198
static char *data_codec_name = NULL;
199
static unsigned int data_codec_tag = 0;
200

    
201
static float mux_preload= 0.5;
202
static float mux_max_delay= 0.7;
203

    
204
static int64_t recording_time = INT64_MAX;
205
static int64_t start_time = 0;
206
static int64_t recording_timestamp = 0;
207
static int64_t input_ts_offset = 0;
208
static int file_overwrite = 0;
209
static AVMetadata *metadata;
210
static int do_benchmark = 0;
211
static int do_hex_dump = 0;
212
static int do_pkt_dump = 0;
213
static int do_psnr = 0;
214
static int do_pass = 0;
215
static const char *pass_logfilename_prefix;
216
static int audio_stream_copy = 0;
217
static int video_stream_copy = 0;
218
static int subtitle_stream_copy = 0;
219
static int data_stream_copy = 0;
220
static int video_sync_method= -1;
221
static int audio_sync_method= 0;
222
static float audio_drift_threshold= 0.1;
223
static int copy_ts= 0;
224
static int copy_tb;
225
static int opt_shortest = 0;
226
static int video_global_header = 0;
227
static char *vstats_filename;
228
static FILE *vstats_file;
229
static int opt_programid = 0;
230
static int copy_initial_nonkeyframes = 0;
231

    
232
static int rate_emu = 0;
233

    
234
static int  video_channel = 0;
235
static char *video_standard;
236

    
237
static int audio_volume = 256;
238

    
239
static int exit_on_error = 0;
240
static int using_stdin = 0;
241
static int verbose = 1;
242
static int run_as_daemon  = 0;
243
static int thread_count= 1;
244
static int q_pressed = 0;
245
static int64_t video_size = 0;
246
static int64_t audio_size = 0;
247
static int64_t extra_size = 0;
248
static int nb_frames_dup = 0;
249
static int nb_frames_drop = 0;
250
static int input_sync;
251
static uint64_t limit_filesize = 0;
252
static int force_fps = 0;
253
static char *forced_key_frames = NULL;
254

    
255
static float dts_delta_threshold = 10;
256

    
257
static int64_t timer_start;
258

    
259
static uint8_t *audio_buf;
260
static uint8_t *audio_out;
261
static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
262

    
263
static short *samples;
264

    
265
static AVBitStreamFilterContext *video_bitstream_filters=NULL;
266
static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
267
static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
268

    
269
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
270

    
271
struct AVInputStream;
272

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

    
294
    float frame_aspect_ratio;
295

    
296
    /* forced key frames */
297
    int64_t *forced_kf_pts;
298
    int forced_kf_count;
299
    int forced_kf_index;
300

    
301
    /* audio only */
302
    int audio_resample;
303
    ReSampleContext *resample; /* for audio resampling */
304
    int resample_sample_fmt;
305
    int resample_channels;
306
    int resample_sample_rate;
307
    int reformat_pair;
308
    AVAudioConvert *reformat_ctx;
309
    AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
310
    FILE *logfile;
311

    
312
#if CONFIG_AVFILTER
313
    AVFilterContext *output_video_filter;
314
    AVFilterContext *input_video_filter;
315
    AVFilterBufferRef *picref;
316
    char *avfilter;
317
    AVFilterGraph *graph;
318
#endif
319
} AVOutputStream;
320

    
321
static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
322
static int nb_output_streams_for_file[MAX_FILES] = { 0 };
323

    
324
typedef struct AVInputStream {
325
    int file_index;
326
    int index;
327
    AVStream *st;
328
    int discard;             /* true if stream data should be discarded */
329
    int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
330
    int64_t sample_index;      /* current sample */
331

    
332
    int64_t       start;     /* time when read started */
333
    int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
334
                                is not defined */
335
    int64_t       pts;       /* current pts */
336
    int is_start;            /* is 1 at the start and after a discontinuity */
337
    int showed_multi_packet_warning;
338
    int is_past_recording_time;
339
#if CONFIG_AVFILTER
340
    AVFrame *filter_frame;
341
    int has_filter_frame;
342
#endif
343
} AVInputStream;
344

    
345
typedef struct AVInputFile {
346
    int eof_reached;      /* true if eof reached */
347
    int ist_index;        /* index of first stream in ist_table */
348
    int buffer_size;      /* current total buffer size */
349
    int nb_streams;       /* nb streams we are aware of */
350
} AVInputFile;
351

    
352
#if HAVE_TERMIOS_H
353

    
354
/* init terminal so that we can grab keys */
355
static struct termios oldtty;
356
#endif
357

    
358
#if CONFIG_AVFILTER
359

    
360
static int configure_video_filters(AVInputStream *ist, AVOutputStream *ost)
361
{
362
    AVFilterContext *last_filter, *filter;
363
    /** filter graph containing all filters including input & output */
364
    AVCodecContext *codec = ost->st->codec;
365
    AVCodecContext *icodec = ist->st->codec;
366
    FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
367
    AVRational sample_aspect_ratio;
368
    char args[255];
369
    int ret;
370

    
371
    ost->graph = avfilter_graph_alloc();
372

    
373
    if (ist->st->sample_aspect_ratio.num){
374
        sample_aspect_ratio = ist->st->sample_aspect_ratio;
375
    }else
376
        sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
377

    
378
    snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
379
             ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
380
             sample_aspect_ratio.num, sample_aspect_ratio.den);
381

    
382
    ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
383
                                       "src", args, NULL, ost->graph);
384
    if (ret < 0)
385
        return ret;
386
    ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
387
                                       "out", NULL, &ffsink_ctx, ost->graph);
388
    if (ret < 0)
389
        return ret;
390
    last_filter = ost->input_video_filter;
391

    
392
    if (codec->width  != icodec->width || codec->height != icodec->height) {
393
        snprintf(args, 255, "%d:%d:flags=0x%X",
394
                 codec->width,
395
                 codec->height,
396
                 (int)av_get_int(sws_opts, "sws_flags", NULL));
397
        if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
398
                                                NULL, args, NULL, ost->graph)) < 0)
399
            return ret;
400
        if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
401
            return ret;
402
        last_filter = filter;
403
    }
404

    
405
    snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL));
406
    ost->graph->scale_sws_opts = av_strdup(args);
407

    
408
    if (ost->avfilter) {
409
        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
410
        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
411

    
412
        outputs->name    = av_strdup("in");
413
        outputs->filter_ctx = last_filter;
414
        outputs->pad_idx = 0;
415
        outputs->next    = NULL;
416

    
417
        inputs->name    = av_strdup("out");
418
        inputs->filter_ctx = ost->output_video_filter;
419
        inputs->pad_idx = 0;
420
        inputs->next    = NULL;
421

    
422
        if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
423
            return ret;
424
        av_freep(&ost->avfilter);
425
    } else {
426
        if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
427
            return ret;
428
    }
429

    
430
    if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
431
        return ret;
432

    
433
    codec->width  = ost->output_video_filter->inputs[0]->w;
434
    codec->height = ost->output_video_filter->inputs[0]->h;
435
    codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
436
        ost->frame_aspect_ratio ? // overriden by the -aspect cli option
437
        av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
438
        ost->output_video_filter->inputs[0]->sample_aspect_ratio;
439

    
440
    return 0;
441
}
442
#endif /* CONFIG_AVFILTER */
443

    
444
static void term_exit(void)
445
{
446
    av_log(NULL, AV_LOG_QUIET, "");
447
#if HAVE_TERMIOS_H
448
    if(!run_as_daemon)
449
        tcsetattr (0, TCSANOW, &oldtty);
450
#endif
451
}
452

    
453
static volatile int received_sigterm = 0;
454

    
455
static void
456
sigterm_handler(int sig)
457
{
458
    received_sigterm = sig;
459
    q_pressed++;
460
    term_exit();
461
}
462

    
463
static void term_init(void)
464
{
465
#if HAVE_TERMIOS_H
466
    if(!run_as_daemon){
467
    struct termios tty;
468

    
469
    tcgetattr (0, &tty);
470
    oldtty = tty;
471
    atexit(term_exit);
472

    
473
    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
474
                          |INLCR|IGNCR|ICRNL|IXON);
475
    tty.c_oflag |= OPOST;
476
    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
477
    tty.c_cflag &= ~(CSIZE|PARENB);
478
    tty.c_cflag |= CS8;
479
    tty.c_cc[VMIN] = 1;
480
    tty.c_cc[VTIME] = 0;
481

    
482
    tcsetattr (0, TCSANOW, &tty);
483
    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
484
    }
485
#endif
486

    
487
    signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
488
    signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
489
#ifdef SIGXCPU
490
    signal(SIGXCPU, sigterm_handler);
491
#endif
492
}
493

    
494
/* read a key without blocking */
495
static int read_key(void)
496
{
497
#if HAVE_TERMIOS_H
498
    int n = 1;
499
    unsigned char ch;
500
    struct timeval tv;
501
    fd_set rfds;
502

    
503
    if(run_as_daemon)
504
        return -1;
505

    
506
    FD_ZERO(&rfds);
507
    FD_SET(0, &rfds);
508
    tv.tv_sec = 0;
509
    tv.tv_usec = 0;
510
    n = select(1, &rfds, NULL, NULL, &tv);
511
    if (n > 0) {
512
        n = read(0, &ch, 1);
513
        if (n == 1)
514
            return ch;
515

    
516
        return n;
517
    }
518
#elif HAVE_KBHIT
519
    if(kbhit())
520
        return(getch());
521
#endif
522
    return -1;
523
}
524

    
525
static int decode_interrupt_cb(void)
526
{
527
    q_pressed += read_key() == 'q';
528
    return q_pressed > 1;
529
}
530

    
531
static int ffmpeg_exit(int ret)
532
{
533
    int i;
534

    
535
    /* close files */
536
    for(i=0;i<nb_output_files;i++) {
537
        AVFormatContext *s = output_files[i];
538
        if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
539
            avio_close(s->pb);
540
        avformat_free_context(s);
541
        av_free(output_streams_for_file[i]);
542
    }
543
    for(i=0;i<nb_input_files;i++) {
544
        av_close_input_file(input_files[i]);
545
        av_free(input_files_ts_scale[i]);
546
    }
547

    
548
    av_free(intra_matrix);
549
    av_free(inter_matrix);
550

    
551
    if (vstats_file)
552
        fclose(vstats_file);
553
    av_free(vstats_filename);
554

    
555
    av_free(streamid_map);
556
    av_free(input_codecs);
557
    av_free(output_codecs);
558
    av_free(stream_maps);
559
    av_free(meta_data_maps);
560

    
561
    av_free(video_codec_name);
562
    av_free(audio_codec_name);
563
    av_free(subtitle_codec_name);
564
    av_free(data_codec_name);
565

    
566
    av_free(video_standard);
567

    
568
    uninit_opts();
569
    av_free(audio_buf);
570
    av_free(audio_out);
571
    allocated_audio_buf_size= allocated_audio_out_size= 0;
572
    av_free(samples);
573

    
574
#if CONFIG_AVFILTER
575
    avfilter_uninit();
576
#endif
577

    
578
    if (received_sigterm) {
579
        fprintf(stderr,
580
            "Received signal %d: terminating.\n",
581
            (int) received_sigterm);
582
        exit (255);
583
    }
584

    
585
    exit(ret); /* not all OS-es handle main() return value */
586
    return ret;
587
}
588

    
589
/* similar to ff_dynarray_add() and av_fast_realloc() */
590
static void *grow_array(void *array, int elem_size, int *size, int new_size)
591
{
592
    if (new_size >= INT_MAX / elem_size) {
593
        fprintf(stderr, "Array too big.\n");
594
        ffmpeg_exit(1);
595
    }
596
    if (*size < new_size) {
597
        uint8_t *tmp = av_realloc(array, new_size*elem_size);
598
        if (!tmp) {
599
            fprintf(stderr, "Could not alloc buffer.\n");
600
            ffmpeg_exit(1);
601
        }
602
        memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
603
        *size = new_size;
604
        return tmp;
605
    }
606
    return array;
607
}
608

    
609
static void choose_sample_fmt(AVStream *st, AVCodec *codec)
610
{
611
    if(codec && codec->sample_fmts){
612
        const enum AVSampleFormat *p= codec->sample_fmts;
613
        for(; *p!=-1; p++){
614
            if(*p == st->codec->sample_fmt)
615
                break;
616
        }
617
        if (*p == -1) {
618
            av_log(NULL, AV_LOG_WARNING,
619
                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
620
                   av_get_sample_fmt_name(st->codec->sample_fmt),
621
                   codec->name,
622
                   av_get_sample_fmt_name(codec->sample_fmts[0]));
623
            st->codec->sample_fmt = codec->sample_fmts[0];
624
        }
625
    }
626
}
627

    
628
static void choose_sample_rate(AVStream *st, AVCodec *codec)
629
{
630
    if(codec && codec->supported_samplerates){
631
        const int *p= codec->supported_samplerates;
632
        int best=0;
633
        int best_dist=INT_MAX;
634
        for(; *p; p++){
635
            int dist= abs(st->codec->sample_rate - *p);
636
            if(dist < best_dist){
637
                best_dist= dist;
638
                best= *p;
639
            }
640
        }
641
        if(best_dist){
642
            av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
643
        }
644
        st->codec->sample_rate= best;
645
    }
646
}
647

    
648
static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
649
{
650
    if(codec && codec->pix_fmts){
651
        const enum PixelFormat *p= codec->pix_fmts;
652
        if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
653
            if(st->codec->codec_id==CODEC_ID_MJPEG){
654
                p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
655
            }else if(st->codec->codec_id==CODEC_ID_LJPEG){
656
                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};
657
            }
658
        }
659
        for(; *p!=-1; p++){
660
            if(*p == st->codec->pix_fmt)
661
                break;
662
        }
663
        if (*p == -1) {
664
            if(st->codec->pix_fmt != PIX_FMT_NONE)
665
            av_log(NULL, AV_LOG_WARNING,
666
                   "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
667
                   av_pix_fmt_descriptors[st->codec->pix_fmt].name,
668
                   codec->name,
669
                   av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
670
            st->codec->pix_fmt = codec->pix_fmts[0];
671
        }
672
    }
673
}
674

    
675
static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
676
{
677
    int idx = oc->nb_streams - 1;
678
    AVOutputStream *ost;
679

    
680
    output_streams_for_file[file_idx] =
681
        grow_array(output_streams_for_file[file_idx],
682
                   sizeof(*output_streams_for_file[file_idx]),
683
                   &nb_output_streams_for_file[file_idx],
684
                   oc->nb_streams);
685
    ost = output_streams_for_file[file_idx][idx] =
686
        av_mallocz(sizeof(AVOutputStream));
687
    if (!ost) {
688
        fprintf(stderr, "Could not alloc output stream\n");
689
        ffmpeg_exit(1);
690
    }
691
    ost->file_index = file_idx;
692
    ost->index = idx;
693
    return ost;
694
}
695

    
696
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
697
{
698
    int i, err;
699
    AVFormatContext *ic;
700
    int nopts = 0;
701

    
702
    err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
703
    if (err < 0)
704
        return err;
705
    /* copy stream format */
706
    s->nb_streams = 0;
707
    for(i=0;i<ic->nb_streams;i++) {
708
        AVStream *st;
709
        AVCodec *codec;
710

    
711
        s->nb_streams++;
712

    
713
        // FIXME: a more elegant solution is needed
714
        st = av_mallocz(sizeof(AVStream));
715
        memcpy(st, ic->streams[i], sizeof(AVStream));
716
        st->codec = avcodec_alloc_context();
717
        if (!st->codec) {
718
            print_error(filename, AVERROR(ENOMEM));
719
            ffmpeg_exit(1);
720
        }
721
        avcodec_copy_context(st->codec, ic->streams[i]->codec);
722
        s->streams[i] = st;
723

    
724
        codec = avcodec_find_encoder(st->codec->codec_id);
725
        if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
726
            if (audio_stream_copy) {
727
                st->stream_copy = 1;
728
            } else
729
                choose_sample_fmt(st, codec);
730
        } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
731
            if (video_stream_copy) {
732
                st->stream_copy = 1;
733
            } else
734
                choose_pixel_fmt(st, codec);
735
        }
736

    
737
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
738
            nopts = 1;
739

    
740
        new_output_stream(s, nb_output_files);
741
    }
742

    
743
    if (!nopts)
744
        s->timestamp = av_gettime();
745

    
746
    av_close_input_file(ic);
747
    return 0;
748
}
749

    
750
static double
751
get_sync_ipts(const AVOutputStream *ost)
752
{
753
    const AVInputStream *ist = ost->sync_ist;
754
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
755
}
756

    
757
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
758
    int ret;
759

    
760
    while(bsfc){
761
        AVPacket new_pkt= *pkt;
762
        int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
763
                                          &new_pkt.data, &new_pkt.size,
764
                                          pkt->data, pkt->size,
765
                                          pkt->flags & AV_PKT_FLAG_KEY);
766
        if(a>0){
767
            av_free_packet(pkt);
768
            new_pkt.destruct= av_destruct_packet;
769
        } else if(a<0){
770
            fprintf(stderr, "%s failed for stream %d, codec %s",
771
                    bsfc->filter->name, pkt->stream_index,
772
                    avctx->codec ? avctx->codec->name : "copy");
773
            print_error("", a);
774
            if (exit_on_error)
775
                ffmpeg_exit(1);
776
        }
777
        *pkt= new_pkt;
778

    
779
        bsfc= bsfc->next;
780
    }
781

    
782
    ret= av_interleaved_write_frame(s, pkt);
783
    if(ret < 0){
784
        print_error("av_interleaved_write_frame()", ret);
785
        ffmpeg_exit(1);
786
    }
787
}
788

    
789
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
790

    
791
static void do_audio_out(AVFormatContext *s,
792
                         AVOutputStream *ost,
793
                         AVInputStream *ist,
794
                         unsigned char *buf, int size)
795
{
796
    uint8_t *buftmp;
797
    int64_t audio_out_size, audio_buf_size;
798
    int64_t allocated_for_size= size;
799

    
800
    int size_out, frame_bytes, ret, resample_changed;
801
    AVCodecContext *enc= ost->st->codec;
802
    AVCodecContext *dec= ist->st->codec;
803
    int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
804
    int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
805
    const int coded_bps = av_get_bits_per_sample(enc->codec->id);
806

    
807
need_realloc:
808
    audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
809
    audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
810
    audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
811
    audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
812
    audio_buf_size*= osize*enc->channels;
813

    
814
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
815
    if(coded_bps > 8*osize)
816
        audio_out_size= audio_out_size * coded_bps / (8*osize);
817
    audio_out_size += FF_MIN_BUFFER_SIZE;
818

    
819
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
820
        fprintf(stderr, "Buffer sizes too large\n");
821
        ffmpeg_exit(1);
822
    }
823

    
824
    av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
825
    av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
826
    if (!audio_buf || !audio_out){
827
        fprintf(stderr, "Out of memory in do_audio_out\n");
828
        ffmpeg_exit(1);
829
    }
830

    
831
    if (enc->channels != dec->channels)
832
        ost->audio_resample = 1;
833

    
834
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
835
                       ost->resample_channels    != dec->channels   ||
836
                       ost->resample_sample_rate != dec->sample_rate;
837

    
838
    if ((ost->audio_resample && !ost->resample) || resample_changed) {
839
        if (resample_changed) {
840
            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",
841
                   ist->file_index, ist->index,
842
                   ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
843
                   dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
844
            ost->resample_sample_fmt  = dec->sample_fmt;
845
            ost->resample_channels    = dec->channels;
846
            ost->resample_sample_rate = dec->sample_rate;
847
            if (ost->resample)
848
                audio_resample_close(ost->resample);
849
        }
850
        /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
851
        if (audio_sync_method <= 1 &&
852
            ost->resample_sample_fmt  == enc->sample_fmt &&
853
            ost->resample_channels    == enc->channels   &&
854
            ost->resample_sample_rate == enc->sample_rate) {
855
            ost->resample = NULL;
856
            ost->audio_resample = 0;
857
        } else {
858
            if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
859
                fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
860
            ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
861
                                                   enc->sample_rate, dec->sample_rate,
862
                                                   enc->sample_fmt,  dec->sample_fmt,
863
                                                   16, 10, 0, 0.8);
864
            if (!ost->resample) {
865
                fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
866
                        dec->channels, dec->sample_rate,
867
                        enc->channels, enc->sample_rate);
868
                ffmpeg_exit(1);
869
            }
870
        }
871
    }
872

    
873
#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
874
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
875
        MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
876
        if (ost->reformat_ctx)
877
            av_audio_convert_free(ost->reformat_ctx);
878
        ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
879
                                                   dec->sample_fmt, 1, NULL, 0);
880
        if (!ost->reformat_ctx) {
881
            fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
882
                av_get_sample_fmt_name(dec->sample_fmt),
883
                av_get_sample_fmt_name(enc->sample_fmt));
884
            ffmpeg_exit(1);
885
        }
886
        ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
887
    }
888

    
889
    if(audio_sync_method){
890
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
891
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
892
        double idelta= delta*dec->sample_rate / enc->sample_rate;
893
        int byte_delta= ((int)idelta)*2*dec->channels;
894

    
895
        //FIXME resample delay
896
        if(fabs(delta) > 50){
897
            if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
898
                if(byte_delta < 0){
899
                    byte_delta= FFMAX(byte_delta, -size);
900
                    size += byte_delta;
901
                    buf  -= byte_delta;
902
                    if(verbose > 2)
903
                        fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
904
                    if(!size)
905
                        return;
906
                    ist->is_start=0;
907
                }else{
908
                    static uint8_t *input_tmp= NULL;
909
                    input_tmp= av_realloc(input_tmp, byte_delta + size);
910

    
911
                    if(byte_delta > allocated_for_size - size){
912
                        allocated_for_size= byte_delta + (int64_t)size;
913
                        goto need_realloc;
914
                    }
915
                    ist->is_start=0;
916

    
917
                    memset(input_tmp, 0, byte_delta);
918
                    memcpy(input_tmp + byte_delta, buf, size);
919
                    buf= input_tmp;
920
                    size += byte_delta;
921
                    if(verbose > 2)
922
                        fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
923
                }
924
            }else if(audio_sync_method>1){
925
                int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
926
                av_assert0(ost->audio_resample);
927
                if(verbose > 2)
928
                    fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
929
//                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));
930
                av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
931
            }
932
        }
933
    }else
934
        ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
935
                        - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
936

    
937
    if (ost->audio_resample) {
938
        buftmp = audio_buf;
939
        size_out = audio_resample(ost->resample,
940
                                  (short *)buftmp, (short *)buf,
941
                                  size / (dec->channels * isize));
942
        size_out = size_out * enc->channels * osize;
943
    } else {
944
        buftmp = buf;
945
        size_out = size;
946
    }
947

    
948
    if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
949
        const void *ibuf[6]= {buftmp};
950
        void *obuf[6]= {audio_buf};
951
        int istride[6]= {isize};
952
        int ostride[6]= {osize};
953
        int len= size_out/istride[0];
954
        if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
955
            printf("av_audio_convert() failed\n");
956
            if (exit_on_error)
957
                ffmpeg_exit(1);
958
            return;
959
        }
960
        buftmp = audio_buf;
961
        size_out = len*osize;
962
    }
963

    
964
    /* now encode as many frames as possible */
965
    if (enc->frame_size > 1) {
966
        /* output resampled raw samples */
967
        if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
968
            fprintf(stderr, "av_fifo_realloc2() failed\n");
969
            ffmpeg_exit(1);
970
        }
971
        av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
972

    
973
        frame_bytes = enc->frame_size * osize * enc->channels;
974

    
975
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
976
            AVPacket pkt;
977
            av_init_packet(&pkt);
978

    
979
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
980

    
981
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
982

    
983
            ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
984
                                       (short *)audio_buf);
985
            if (ret < 0) {
986
                fprintf(stderr, "Audio encoding failed\n");
987
                ffmpeg_exit(1);
988
            }
989
            audio_size += ret;
990
            pkt.stream_index= ost->index;
991
            pkt.data= audio_out;
992
            pkt.size= ret;
993
            if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
994
                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
995
            pkt.flags |= AV_PKT_FLAG_KEY;
996
            write_frame(s, &pkt, enc, ost->bitstream_filters);
997

    
998
            ost->sync_opts += enc->frame_size;
999
        }
1000
    } else {
1001
        AVPacket pkt;
1002
        av_init_packet(&pkt);
1003

    
1004
        ost->sync_opts += size_out / (osize * enc->channels);
1005

    
1006
        /* output a pcm frame */
1007
        /* determine the size of the coded buffer */
1008
        size_out /= osize;
1009
        if (coded_bps)
1010
            size_out = size_out*coded_bps/8;
1011

    
1012
        if(size_out > audio_out_size){
1013
            fprintf(stderr, "Internal error, buffer size too small\n");
1014
            ffmpeg_exit(1);
1015
        }
1016

    
1017
        //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1018
        ret = avcodec_encode_audio(enc, audio_out, size_out,
1019
                                   (short *)buftmp);
1020
        if (ret < 0) {
1021
            fprintf(stderr, "Audio encoding failed\n");
1022
            ffmpeg_exit(1);
1023
        }
1024
        audio_size += ret;
1025
        pkt.stream_index= ost->index;
1026
        pkt.data= audio_out;
1027
        pkt.size= ret;
1028
        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1029
            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1030
        pkt.flags |= AV_PKT_FLAG_KEY;
1031
        write_frame(s, &pkt, enc, ost->bitstream_filters);
1032
    }
1033
}
1034

    
1035
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1036
{
1037
    AVCodecContext *dec;
1038
    AVPicture *picture2;
1039
    AVPicture picture_tmp;
1040
    uint8_t *buf = 0;
1041

    
1042
    dec = ist->st->codec;
1043

    
1044
    /* deinterlace : must be done before any resize */
1045
    if (do_deinterlace) {
1046
        int size;
1047

    
1048
        /* create temporary picture */
1049
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1050
        buf = av_malloc(size);
1051
        if (!buf)
1052
            return;
1053

    
1054
        picture2 = &picture_tmp;
1055
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1056

    
1057
        if(avpicture_deinterlace(picture2, picture,
1058
                                 dec->pix_fmt, dec->width, dec->height) < 0) {
1059
            /* if error, do not deinterlace */
1060
            fprintf(stderr, "Deinterlacing failed\n");
1061
            av_free(buf);
1062
            buf = NULL;
1063
            picture2 = picture;
1064
        }
1065
    } else {
1066
        picture2 = picture;
1067
    }
1068

    
1069
    if (picture != picture2)
1070
        *picture = *picture2;
1071
    *bufp = buf;
1072
}
1073

    
1074
/* we begin to correct av delay at this threshold */
1075
#define AV_DELAY_MAX 0.100
1076

    
1077
static void do_subtitle_out(AVFormatContext *s,
1078
                            AVOutputStream *ost,
1079
                            AVInputStream *ist,
1080
                            AVSubtitle *sub,
1081
                            int64_t pts)
1082
{
1083
    static uint8_t *subtitle_out = NULL;
1084
    int subtitle_out_max_size = 1024 * 1024;
1085
    int subtitle_out_size, nb, i;
1086
    AVCodecContext *enc;
1087
    AVPacket pkt;
1088

    
1089
    if (pts == AV_NOPTS_VALUE) {
1090
        fprintf(stderr, "Subtitle packets must have a pts\n");
1091
        if (exit_on_error)
1092
            ffmpeg_exit(1);
1093
        return;
1094
    }
1095

    
1096
    enc = ost->st->codec;
1097

    
1098
    if (!subtitle_out) {
1099
        subtitle_out = av_malloc(subtitle_out_max_size);
1100
    }
1101

    
1102
    /* Note: DVB subtitle need one packet to draw them and one other
1103
       packet to clear them */
1104
    /* XXX: signal it in the codec context ? */
1105
    if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1106
        nb = 2;
1107
    else
1108
        nb = 1;
1109

    
1110
    for(i = 0; i < nb; i++) {
1111
        sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1112
        // start_display_time is required to be 0
1113
        sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1114
        sub->end_display_time -= sub->start_display_time;
1115
        sub->start_display_time = 0;
1116
        subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1117
                                                    subtitle_out_max_size, sub);
1118
        if (subtitle_out_size < 0) {
1119
            fprintf(stderr, "Subtitle encoding failed\n");
1120
            ffmpeg_exit(1);
1121
        }
1122

    
1123
        av_init_packet(&pkt);
1124
        pkt.stream_index = ost->index;
1125
        pkt.data = subtitle_out;
1126
        pkt.size = subtitle_out_size;
1127
        pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1128
        if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1129
            /* XXX: the pts correction is handled here. Maybe handling
1130
               it in the codec would be better */
1131
            if (i == 0)
1132
                pkt.pts += 90 * sub->start_display_time;
1133
            else
1134
                pkt.pts += 90 * sub->end_display_time;
1135
        }
1136
        write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1137
    }
1138
}
1139

    
1140
static int bit_buffer_size= 1024*256;
1141
static uint8_t *bit_buffer= NULL;
1142

    
1143
static void do_video_out(AVFormatContext *s,
1144
                         AVOutputStream *ost,
1145
                         AVInputStream *ist,
1146
                         AVFrame *in_picture,
1147
                         int *frame_size)
1148
{
1149
    int nb_frames, i, ret, resample_changed;
1150
    AVFrame *final_picture, *formatted_picture;
1151
    AVCodecContext *enc, *dec;
1152
    double sync_ipts;
1153

    
1154
    enc = ost->st->codec;
1155
    dec = ist->st->codec;
1156

    
1157
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1158

    
1159
    /* by default, we output a single frame */
1160
    nb_frames = 1;
1161

    
1162
    *frame_size = 0;
1163

    
1164
    if(video_sync_method){
1165
        double vdelta = sync_ipts - ost->sync_opts;
1166
        //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1167
        if (vdelta < -1.1)
1168
            nb_frames = 0;
1169
        else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1170
            if(vdelta<=-0.6){
1171
                nb_frames=0;
1172
            }else if(vdelta>0.6)
1173
                ost->sync_opts= lrintf(sync_ipts);
1174
        }else if (vdelta > 1.1)
1175
            nb_frames = lrintf(vdelta);
1176
//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);
1177
        if (nb_frames == 0){
1178
            ++nb_frames_drop;
1179
            if (verbose>2)
1180
                fprintf(stderr, "*** drop!\n");
1181
        }else if (nb_frames > 1) {
1182
            nb_frames_dup += nb_frames - 1;
1183
            if (verbose>2)
1184
                fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1185
        }
1186
    }else
1187
        ost->sync_opts= lrintf(sync_ipts);
1188

    
1189
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1190
    if (nb_frames <= 0)
1191
        return;
1192

    
1193
    formatted_picture = in_picture;
1194
    final_picture = formatted_picture;
1195

    
1196
    resample_changed = ost->resample_width   != dec->width  ||
1197
                       ost->resample_height  != dec->height ||
1198
                       ost->resample_pix_fmt != dec->pix_fmt;
1199

    
1200
    if (resample_changed) {
1201
        av_log(NULL, AV_LOG_INFO,
1202
               "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1203
               ist->file_index, ist->index,
1204
               ost->resample_width, ost->resample_height, avcodec_get_pix_fmt_name(ost->resample_pix_fmt),
1205
               dec->width         , dec->height         , avcodec_get_pix_fmt_name(dec->pix_fmt));
1206
        ost->resample_width   = dec->width;
1207
        ost->resample_height  = dec->height;
1208
        ost->resample_pix_fmt = dec->pix_fmt;
1209
    }
1210

    
1211
#if !CONFIG_AVFILTER
1212
    ost->video_resample = dec->width   != enc->width  ||
1213
                          dec->height  != enc->height ||
1214
                          dec->pix_fmt != enc->pix_fmt;
1215

    
1216
    if (ost->video_resample) {
1217
        final_picture = &ost->pict_tmp;
1218
        if (!ost->img_resample_ctx || resample_changed) {
1219
            /* initialize the destination picture */
1220
            if (!ost->pict_tmp.data[0]) {
1221
                avcodec_get_frame_defaults(&ost->pict_tmp);
1222
                if (avpicture_alloc((AVPicture *)&ost->pict_tmp, enc->pix_fmt,
1223
                                    enc->width, enc->height)) {
1224
                    fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1225
                    ffmpeg_exit(1);
1226
                }
1227
            }
1228
            /* initialize a new scaler context */
1229
            sws_freeContext(ost->img_resample_ctx);
1230
            sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1231
            ost->img_resample_ctx = sws_getContext(
1232
                ist->st->codec->width,
1233
                ist->st->codec->height,
1234
                ist->st->codec->pix_fmt,
1235
                ost->st->codec->width,
1236
                ost->st->codec->height,
1237
                ost->st->codec->pix_fmt,
1238
                sws_flags, NULL, NULL, NULL);
1239
            if (ost->img_resample_ctx == NULL) {
1240
                fprintf(stderr, "Cannot get resampling context\n");
1241
                ffmpeg_exit(1);
1242
            }
1243
        }
1244
        sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1245
                  0, ost->resample_height, ost->pict_tmp.data, ost->pict_tmp.linesize);
1246
    }
1247
#endif
1248

    
1249
    /* duplicates frame if needed */
1250
    for(i=0;i<nb_frames;i++) {
1251
        AVPacket pkt;
1252
        av_init_packet(&pkt);
1253
        pkt.stream_index= ost->index;
1254

    
1255
        if (s->oformat->flags & AVFMT_RAWPICTURE) {
1256
            /* raw pictures are written as AVPicture structure to
1257
               avoid any copies. We support temorarily the older
1258
               method. */
1259
            AVFrame* old_frame = enc->coded_frame;
1260
            enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1261
            pkt.data= (uint8_t *)final_picture;
1262
            pkt.size=  sizeof(AVPicture);
1263
            pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1264
            pkt.flags |= AV_PKT_FLAG_KEY;
1265

    
1266
            write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1267
            enc->coded_frame = old_frame;
1268
        } else {
1269
            AVFrame big_picture;
1270

    
1271
            big_picture= *final_picture;
1272
            /* better than nothing: use input picture interlaced
1273
               settings */
1274
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1275
            if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1276
                if(top_field_first == -1)
1277
                    big_picture.top_field_first = in_picture->top_field_first;
1278
                else
1279
                    big_picture.top_field_first = top_field_first;
1280
            }
1281

    
1282
            /* handles sameq here. This is not correct because it may
1283
               not be a global option */
1284
            big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1285
            if(!me_threshold)
1286
                big_picture.pict_type = 0;
1287
//            big_picture.pts = AV_NOPTS_VALUE;
1288
            big_picture.pts= ost->sync_opts;
1289
//            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1290
//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1291
            if (ost->forced_kf_index < ost->forced_kf_count &&
1292
                big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1293
                big_picture.pict_type = AV_PICTURE_TYPE_I;
1294
                ost->forced_kf_index++;
1295
            }
1296
            ret = avcodec_encode_video(enc,
1297
                                       bit_buffer, bit_buffer_size,
1298
                                       &big_picture);
1299
            if (ret < 0) {
1300
                fprintf(stderr, "Video encoding failed\n");
1301
                ffmpeg_exit(1);
1302
            }
1303

    
1304
            if(ret>0){
1305
                pkt.data= bit_buffer;
1306
                pkt.size= ret;
1307
                if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1308
                    pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1309
/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1310
   pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1311
   pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1312

    
1313
                if(enc->coded_frame->key_frame)
1314
                    pkt.flags |= AV_PKT_FLAG_KEY;
1315
                write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1316
                *frame_size = ret;
1317
                video_size += ret;
1318
                //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1319
                //        enc->frame_number-1, ret, enc->pict_type);
1320
                /* if two pass, output log */
1321
                if (ost->logfile && enc->stats_out) {
1322
                    fprintf(ost->logfile, "%s", enc->stats_out);
1323
                }
1324
            }
1325
        }
1326
        ost->sync_opts++;
1327
        ost->frame_number++;
1328
    }
1329
}
1330

    
1331
static double psnr(double d){
1332
    return -10.0*log(d)/log(10.0);
1333
}
1334

    
1335
static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1336
                           int frame_size)
1337
{
1338
    AVCodecContext *enc;
1339
    int frame_number;
1340
    double ti1, bitrate, avg_bitrate;
1341

    
1342
    /* this is executed just the first time do_video_stats is called */
1343
    if (!vstats_file) {
1344
        vstats_file = fopen(vstats_filename, "w");
1345
        if (!vstats_file) {
1346
            perror("fopen");
1347
            ffmpeg_exit(1);
1348
        }
1349
    }
1350

    
1351
    enc = ost->st->codec;
1352
    if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1353
        frame_number = ost->frame_number;
1354
        fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1355
        if (enc->flags&CODEC_FLAG_PSNR)
1356
            fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1357

    
1358
        fprintf(vstats_file,"f_size= %6d ", frame_size);
1359
        /* compute pts value */
1360
        ti1 = ost->sync_opts * av_q2d(enc->time_base);
1361
        if (ti1 < 0.01)
1362
            ti1 = 0.01;
1363

    
1364
        bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1365
        avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1366
        fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1367
            (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1368
        fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1369
    }
1370
}
1371

    
1372
static void print_report(AVFormatContext **output_files,
1373
                         AVOutputStream **ost_table, int nb_ostreams,
1374
                         int is_last_report)
1375
{
1376
    char buf[1024];
1377
    AVOutputStream *ost;
1378
    AVFormatContext *oc;
1379
    int64_t total_size;
1380
    AVCodecContext *enc;
1381
    int frame_number, vid, i;
1382
    double bitrate, ti1, pts;
1383
    static int64_t last_time = -1;
1384
    static int qp_histogram[52];
1385

    
1386
    if (!is_last_report) {
1387
        int64_t cur_time;
1388
        /* display the report every 0.5 seconds */
1389
        cur_time = av_gettime();
1390
        if (last_time == -1) {
1391
            last_time = cur_time;
1392
            return;
1393
        }
1394
        if ((cur_time - last_time) < 500000)
1395
            return;
1396
        last_time = cur_time;
1397
    }
1398

    
1399

    
1400
    oc = output_files[0];
1401

    
1402
    total_size = avio_size(oc->pb);
1403
    if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1404
        total_size= avio_tell(oc->pb);
1405

    
1406
    buf[0] = '\0';
1407
    ti1 = 1e10;
1408
    vid = 0;
1409
    for(i=0;i<nb_ostreams;i++) {
1410
        float q= -1;
1411
        ost = ost_table[i];
1412
        enc = ost->st->codec;
1413
        if(!ost->st->stream_copy && enc->coded_frame)
1414
            q= enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1415
        if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1416
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1417
        }
1418
        if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1419
            float t = (av_gettime()-timer_start) / 1000000.0;
1420

    
1421
            frame_number = ost->frame_number;
1422
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1423
                     frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1424
            if(is_last_report)
1425
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1426
            if(qp_hist){
1427
                int j;
1428
                int qp= lrintf(q);
1429
                if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1430
                    qp_histogram[qp]++;
1431
                for(j=0; j<32; j++)
1432
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1433
            }
1434
            if (enc->flags&CODEC_FLAG_PSNR){
1435
                int j;
1436
                double error, error_sum=0;
1437
                double scale, scale_sum=0;
1438
                char type[3]= {'Y','U','V'};
1439
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1440
                for(j=0; j<3; j++){
1441
                    if(is_last_report){
1442
                        error= enc->error[j];
1443
                        scale= enc->width*enc->height*255.0*255.0*frame_number;
1444
                    }else{
1445
                        error= enc->coded_frame->error[j];
1446
                        scale= enc->width*enc->height*255.0*255.0;
1447
                    }
1448
                    if(j) scale/=4;
1449
                    error_sum += error;
1450
                    scale_sum += scale;
1451
                    snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1452
                }
1453
                snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1454
            }
1455
            vid = 1;
1456
        }
1457
        /* compute min output value */
1458
        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1459
        if ((pts < ti1) && (pts > 0))
1460
            ti1 = pts;
1461
    }
1462
    if (ti1 < 0.01)
1463
        ti1 = 0.01;
1464

    
1465
    if (verbose > 0 || is_last_report) {
1466
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1467

    
1468
        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1469
            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1470
            (double)total_size / 1024, ti1, bitrate);
1471

    
1472
        if (nb_frames_dup || nb_frames_drop)
1473
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1474
                  nb_frames_dup, nb_frames_drop);
1475

    
1476
        if (verbose >= 0)
1477
            fprintf(stderr, "%s    \r", buf);
1478

    
1479
        fflush(stderr);
1480
    }
1481

    
1482
    if (is_last_report && verbose >= 0){
1483
        int64_t raw= audio_size + video_size + extra_size;
1484
        fprintf(stderr, "\n");
1485
        fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1486
                video_size/1024.0,
1487
                audio_size/1024.0,
1488
                extra_size/1024.0,
1489
                100.0*(total_size - raw)/raw
1490
        );
1491
    }
1492
}
1493

    
1494
static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1495
{
1496
    int fill_char = 0x00;
1497
    if (sample_fmt == AV_SAMPLE_FMT_U8)
1498
        fill_char = 0x80;
1499
    memset(buf, fill_char, size);
1500
}
1501

    
1502
/* pkt = NULL means EOF (needed to flush decoder buffers) */
1503
static int output_packet(AVInputStream *ist, int ist_index,
1504
                         AVOutputStream **ost_table, int nb_ostreams,
1505
                         const AVPacket *pkt)
1506
{
1507
    AVFormatContext *os;
1508
    AVOutputStream *ost;
1509
    int ret, i;
1510
    int got_picture;
1511
    AVFrame picture;
1512
    void *buffer_to_free = NULL;
1513
    static unsigned int samples_size= 0;
1514
    AVSubtitle subtitle, *subtitle_to_free;
1515
    int64_t pkt_pts = AV_NOPTS_VALUE;
1516
#if CONFIG_AVFILTER
1517
    int frame_available;
1518
#endif
1519

    
1520
    AVPacket avpkt;
1521
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1522

    
1523
    if(ist->next_pts == AV_NOPTS_VALUE)
1524
        ist->next_pts= ist->pts;
1525

    
1526
    if (pkt == NULL) {
1527
        /* EOF handling */
1528
        av_init_packet(&avpkt);
1529
        avpkt.data = NULL;
1530
        avpkt.size = 0;
1531
        goto handle_eof;
1532
    } else {
1533
        avpkt = *pkt;
1534
    }
1535

    
1536
    if(pkt->dts != AV_NOPTS_VALUE)
1537
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1538
    if(pkt->pts != AV_NOPTS_VALUE)
1539
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1540

    
1541
    //while we have more to decode or while the decoder did output something on EOF
1542
    while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1543
        uint8_t *data_buf, *decoded_data_buf;
1544
        int data_size, decoded_data_size;
1545
    handle_eof:
1546
        ist->pts= ist->next_pts;
1547

    
1548
        if(avpkt.size && avpkt.size != pkt->size &&
1549
           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1550
            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1551
            ist->showed_multi_packet_warning=1;
1552
        }
1553

    
1554
        /* decode the packet if needed */
1555
        decoded_data_buf = NULL; /* fail safe */
1556
        decoded_data_size= 0;
1557
        data_buf  = avpkt.data;
1558
        data_size = avpkt.size;
1559
        subtitle_to_free = NULL;
1560
        if (ist->decoding_needed) {
1561
            switch(ist->st->codec->codec_type) {
1562
            case AVMEDIA_TYPE_AUDIO:{
1563
                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1564
                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1565
                    av_free(samples);
1566
                    samples= av_malloc(samples_size);
1567
                }
1568
                decoded_data_size= samples_size;
1569
                    /* XXX: could avoid copy if PCM 16 bits with same
1570
                       endianness as CPU */
1571
                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1572
                                            &avpkt);
1573
                if (ret < 0)
1574
                    goto fail_decode;
1575
                avpkt.data += ret;
1576
                avpkt.size -= ret;
1577
                data_size   = ret;
1578
                /* Some bug in mpeg audio decoder gives */
1579
                /* decoded_data_size < 0, it seems they are overflows */
1580
                if (decoded_data_size <= 0) {
1581
                    /* no audio frame */
1582
                    continue;
1583
                }
1584
                decoded_data_buf = (uint8_t *)samples;
1585
                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1586
                    (ist->st->codec->sample_rate * ist->st->codec->channels);
1587
                break;}
1588
            case AVMEDIA_TYPE_VIDEO:
1589
                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1590
                    /* XXX: allocate picture correctly */
1591
                    avcodec_get_frame_defaults(&picture);
1592
                    avpkt.pts = pkt_pts;
1593
                    avpkt.dts = ist->pts;
1594
                    pkt_pts = AV_NOPTS_VALUE;
1595

    
1596
                    ret = avcodec_decode_video2(ist->st->codec,
1597
                                                &picture, &got_picture, &avpkt);
1598
                    ist->st->quality= picture.quality;
1599
                    if (ret < 0)
1600
                        goto fail_decode;
1601
                    if (!got_picture) {
1602
                        /* no picture yet */
1603
                        goto discard_packet;
1604
                    }
1605
                    ist->next_pts = ist->pts = picture.best_effort_timestamp;
1606
                    if (ist->st->codec->time_base.num != 0) {
1607
                        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1608
                        ist->next_pts += ((int64_t)AV_TIME_BASE *
1609
                                          ist->st->codec->time_base.num * ticks) /
1610
                            ist->st->codec->time_base.den;
1611
                    }
1612
                    avpkt.size = 0;
1613
                    buffer_to_free = NULL;
1614
                    pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1615
                    break;
1616
            case AVMEDIA_TYPE_SUBTITLE:
1617
                ret = avcodec_decode_subtitle2(ist->st->codec,
1618
                                               &subtitle, &got_picture, &avpkt);
1619
                if (ret < 0)
1620
                    goto fail_decode;
1621
                if (!got_picture) {
1622
                    goto discard_packet;
1623
                }
1624
                subtitle_to_free = &subtitle;
1625
                avpkt.size = 0;
1626
                break;
1627
            default:
1628
                goto fail_decode;
1629
            }
1630
        } else {
1631
            switch(ist->st->codec->codec_type) {
1632
            case AVMEDIA_TYPE_AUDIO:
1633
                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1634
                    ist->st->codec->sample_rate;
1635
                break;
1636
            case AVMEDIA_TYPE_VIDEO:
1637
                if (ist->st->codec->time_base.num != 0) {
1638
                    int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1639
                    ist->next_pts += ((int64_t)AV_TIME_BASE *
1640
                                      ist->st->codec->time_base.num * ticks) /
1641
                        ist->st->codec->time_base.den;
1642
                }
1643
                break;
1644
            }
1645
            ret = avpkt.size;
1646
            avpkt.size = 0;
1647
        }
1648

    
1649
#if CONFIG_AVFILTER
1650
        if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
1651
            for(i=0;i<nb_ostreams;i++) {
1652
                ost = ost_table[i];
1653
                if (ost->input_video_filter && ost->source_index == ist_index) {
1654
                    if (!picture.sample_aspect_ratio.num)
1655
                        picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1656
                    // add it to be filtered
1657
                    av_vsrc_buffer_add_frame2(ost->input_video_filter, &picture,
1658
                                             ist->pts,
1659
                                             ist->st->codec->width, ist->st->codec->height,
1660
                                             ist->st->codec->pix_fmt, ""); //TODO user setable params
1661
                }
1662
            }
1663
        }
1664
#endif
1665

    
1666
        // preprocess audio (volume)
1667
        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1668
            if (audio_volume != 256) {
1669
                short *volp;
1670
                volp = samples;
1671
                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1672
                    int v = ((*volp) * audio_volume + 128) >> 8;
1673
                    if (v < -32768) v = -32768;
1674
                    if (v >  32767) v = 32767;
1675
                    *volp++ = v;
1676
                }
1677
            }
1678
        }
1679

    
1680
        /* frame rate emulation */
1681
        if (rate_emu) {
1682
            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1683
            int64_t now = av_gettime() - ist->start;
1684
            if (pts > now)
1685
                usleep(pts - now);
1686
        }
1687
        /* if output time reached then transcode raw format,
1688
           encode packets and output them */
1689
        if (start_time == 0 || ist->pts >= start_time)
1690
            for(i=0;i<nb_ostreams;i++) {
1691
                int frame_size;
1692

    
1693
                ost = ost_table[i];
1694
                if (ost->source_index == ist_index) {
1695
#if CONFIG_AVFILTER
1696
                frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1697
                    !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1698
                while (frame_available) {
1699
                    AVRational ist_pts_tb;
1700
                    if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1701
                        get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1702
                    if (ost->picref)
1703
                        ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1704
#endif
1705
                    os = output_files[ost->file_index];
1706

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

    
1710
                    if (ost->encoding_needed) {
1711
                        av_assert0(ist->decoding_needed);
1712
                        switch(ost->st->codec->codec_type) {
1713
                        case AVMEDIA_TYPE_AUDIO:
1714
                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1715
                            break;
1716
                        case AVMEDIA_TYPE_VIDEO:
1717
#if CONFIG_AVFILTER
1718
                            if (ost->picref->video && !ost->frame_aspect_ratio)
1719
                                ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1720
#endif
1721
                            do_video_out(os, ost, ist, &picture, &frame_size);
1722
                            if (vstats_filename && frame_size)
1723
                                do_video_stats(os, ost, frame_size);
1724
                            break;
1725
                        case AVMEDIA_TYPE_SUBTITLE:
1726
                            do_subtitle_out(os, ost, ist, &subtitle,
1727
                                            pkt->pts);
1728
                            break;
1729
                        default:
1730
                            abort();
1731
                        }
1732
                    } else {
1733
                        AVFrame avframe; //FIXME/XXX remove this
1734
                        AVPacket opkt;
1735
                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1736

    
1737
                        av_init_packet(&opkt);
1738

    
1739
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1740
#if !CONFIG_AVFILTER
1741
                            continue;
1742
#else
1743
                            goto cont;
1744
#endif
1745

    
1746
                        /* no reencoding needed : output the packet directly */
1747
                        /* force the input stream PTS */
1748

    
1749
                        avcodec_get_frame_defaults(&avframe);
1750
                        ost->st->codec->coded_frame= &avframe;
1751
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1752

    
1753
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1754
                            audio_size += data_size;
1755
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1756
                            video_size += data_size;
1757
                            ost->sync_opts++;
1758
                        }
1759

    
1760
                        opkt.stream_index= ost->index;
1761
                        if(pkt->pts != AV_NOPTS_VALUE)
1762
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1763
                        else
1764
                            opkt.pts= AV_NOPTS_VALUE;
1765

    
1766
                        if (pkt->dts == AV_NOPTS_VALUE)
1767
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1768
                        else
1769
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1770
                        opkt.dts -= ost_tb_start_time;
1771

    
1772
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1773
                        opkt.flags= pkt->flags;
1774

    
1775
                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1776
                        if(   ost->st->codec->codec_id != CODEC_ID_H264
1777
                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1778
                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1779
                           ) {
1780
                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1781
                                opkt.destruct= av_destruct_packet;
1782
                        } else {
1783
                            opkt.data = data_buf;
1784
                            opkt.size = data_size;
1785
                        }
1786

    
1787
                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1788
                        ost->st->codec->frame_number++;
1789
                        ost->frame_number++;
1790
                        av_free_packet(&opkt);
1791
                    }
1792
#if CONFIG_AVFILTER
1793
                    cont:
1794
                    frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1795
                                       ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1796
                    if(ost->picref)
1797
                        avfilter_unref_buffer(ost->picref);
1798
                }
1799
#endif
1800
                }
1801
            }
1802

    
1803
        av_free(buffer_to_free);
1804
        /* XXX: allocate the subtitles in the codec ? */
1805
        if (subtitle_to_free) {
1806
            avsubtitle_free(subtitle_to_free);
1807
            subtitle_to_free = NULL;
1808
        }
1809
    }
1810
 discard_packet:
1811
    if (pkt == NULL) {
1812
        /* EOF handling */
1813

    
1814
        for(i=0;i<nb_ostreams;i++) {
1815
            ost = ost_table[i];
1816
            if (ost->source_index == ist_index) {
1817
                AVCodecContext *enc= ost->st->codec;
1818
                os = output_files[ost->file_index];
1819

    
1820
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1821
                    continue;
1822
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1823
                    continue;
1824

    
1825
                if (ost->encoding_needed) {
1826
                    for(;;) {
1827
                        AVPacket pkt;
1828
                        int fifo_bytes;
1829
                        av_init_packet(&pkt);
1830
                        pkt.stream_index= ost->index;
1831

    
1832
                        switch(ost->st->codec->codec_type) {
1833
                        case AVMEDIA_TYPE_AUDIO:
1834
                            fifo_bytes = av_fifo_size(ost->fifo);
1835
                            ret = 0;
1836
                            /* encode any samples remaining in fifo */
1837
                            if (fifo_bytes > 0) {
1838
                                int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1839
                                int fs_tmp = enc->frame_size;
1840

    
1841
                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1842
                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1843
                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
1844
                                } else { /* pad */
1845
                                    int frame_bytes = enc->frame_size*osize*enc->channels;
1846
                                    if (allocated_audio_buf_size < frame_bytes)
1847
                                        ffmpeg_exit(1);
1848
                                    generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1849
                                }
1850

    
1851
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1852
                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1853
                                                          ost->st->time_base.num, enc->sample_rate);
1854
                                enc->frame_size = fs_tmp;
1855
                            }
1856
                            if(ret <= 0) {
1857
                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1858
                            }
1859
                            if (ret < 0) {
1860
                                fprintf(stderr, "Audio encoding failed\n");
1861
                                ffmpeg_exit(1);
1862
                            }
1863
                            audio_size += ret;
1864
                            pkt.flags |= AV_PKT_FLAG_KEY;
1865
                            break;
1866
                        case AVMEDIA_TYPE_VIDEO:
1867
                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1868
                            if (ret < 0) {
1869
                                fprintf(stderr, "Video encoding failed\n");
1870
                                ffmpeg_exit(1);
1871
                            }
1872
                            video_size += ret;
1873
                            if(enc->coded_frame && enc->coded_frame->key_frame)
1874
                                pkt.flags |= AV_PKT_FLAG_KEY;
1875
                            if (ost->logfile && enc->stats_out) {
1876
                                fprintf(ost->logfile, "%s", enc->stats_out);
1877
                            }
1878
                            break;
1879
                        default:
1880
                            ret=-1;
1881
                        }
1882

    
1883
                        if(ret<=0)
1884
                            break;
1885
                        pkt.data= bit_buffer;
1886
                        pkt.size= ret;
1887
                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1888
                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1889
                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1890
                    }
1891
                }
1892
            }
1893
        }
1894
    }
1895

    
1896
    return 0;
1897
 fail_decode:
1898
    return -1;
1899
}
1900

    
1901
static void print_sdp(AVFormatContext **avc, int n)
1902
{
1903
    char sdp[2048];
1904

    
1905
    av_sdp_create(avc, n, sdp, sizeof(sdp));
1906
    printf("SDP:\n%s\n", sdp);
1907
    fflush(stdout);
1908
}
1909

    
1910
static int copy_chapters(int infile, int outfile)
1911
{
1912
    AVFormatContext *is = input_files[infile];
1913
    AVFormatContext *os = output_files[outfile];
1914
    int i;
1915

    
1916
    for (i = 0; i < is->nb_chapters; i++) {
1917
        AVChapter *in_ch = is->chapters[i], *out_ch;
1918
        int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1919
                                      AV_TIME_BASE_Q, in_ch->time_base);
1920
        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1921
                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1922

    
1923

    
1924
        if (in_ch->end < ts_off)
1925
            continue;
1926
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1927
            break;
1928

    
1929
        out_ch = av_mallocz(sizeof(AVChapter));
1930
        if (!out_ch)
1931
            return AVERROR(ENOMEM);
1932

    
1933
        out_ch->id        = in_ch->id;
1934
        out_ch->time_base = in_ch->time_base;
1935
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1936
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1937

    
1938
        if (metadata_chapters_autocopy)
1939
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1940

    
1941
        os->nb_chapters++;
1942
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1943
        if (!os->chapters)
1944
            return AVERROR(ENOMEM);
1945
        os->chapters[os->nb_chapters - 1] = out_ch;
1946
    }
1947
    return 0;
1948
}
1949

    
1950
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1951
                                    AVCodecContext *avctx)
1952
{
1953
    char *p;
1954
    int n = 1, i;
1955
    int64_t t;
1956

    
1957
    for (p = kf; *p; p++)
1958
        if (*p == ',')
1959
            n++;
1960
    ost->forced_kf_count = n;
1961
    ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1962
    if (!ost->forced_kf_pts) {
1963
        av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1964
        ffmpeg_exit(1);
1965
    }
1966
    for (i = 0; i < n; i++) {
1967
        p = i ? strchr(p, ',') + 1 : kf;
1968
        t = parse_time_or_die("force_key_frames", p, 1);
1969
        ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1970
    }
1971
}
1972

    
1973
/*
1974
 * The following code is the main loop of the file converter
1975
 */
1976
static int transcode(AVFormatContext **output_files,
1977
                     int nb_output_files,
1978
                     AVFormatContext **input_files,
1979
                     int nb_input_files,
1980
                     AVStreamMap *stream_maps, int nb_stream_maps)
1981
{
1982
    int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0, step;
1983
    AVFormatContext *is, *os;
1984
    AVCodecContext *codec, *icodec;
1985
    AVOutputStream *ost, **ost_table = NULL;
1986
    AVInputStream *ist, **ist_table = NULL;
1987
    AVInputFile *file_table;
1988
    char error[1024];
1989
    int key;
1990
    int want_sdp = 1;
1991
    uint8_t no_packet[MAX_FILES]={0};
1992
    int no_packet_count=0;
1993
    int nb_frame_threshold[AVMEDIA_TYPE_NB]={0};
1994
    int nb_streams[AVMEDIA_TYPE_NB]={0};
1995

    
1996
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1997
    if (!file_table)
1998
        goto fail;
1999

    
2000
    /* input stream init */
2001
    j = 0;
2002
    for(i=0;i<nb_input_files;i++) {
2003
        is = input_files[i];
2004
        file_table[i].ist_index = j;
2005
        file_table[i].nb_streams = is->nb_streams;
2006
        j += is->nb_streams;
2007
    }
2008
    nb_istreams = j;
2009

    
2010
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
2011
    if (!ist_table)
2012
        goto fail;
2013

    
2014
    for(i=0;i<nb_istreams;i++) {
2015
        ist = av_mallocz(sizeof(AVInputStream));
2016
        if (!ist)
2017
            goto fail;
2018
        ist_table[i] = ist;
2019
    }
2020
    j = 0;
2021
    for(i=0;i<nb_input_files;i++) {
2022
        is = input_files[i];
2023
        for(k=0;k<is->nb_streams;k++) {
2024
            ist = ist_table[j++];
2025
            ist->st = is->streams[k];
2026
            ist->file_index = i;
2027
            ist->index = k;
2028
            ist->discard = 1; /* the stream is discarded by default
2029
                                 (changed later) */
2030

    
2031
            if (rate_emu) {
2032
                ist->start = av_gettime();
2033
            }
2034
        }
2035
    }
2036

    
2037
    /* output stream init */
2038
    nb_ostreams = 0;
2039
    for(i=0;i<nb_output_files;i++) {
2040
        os = output_files[i];
2041
        if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2042
            av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2043
            fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2044
            ret = AVERROR(EINVAL);
2045
            goto fail;
2046
        }
2047
        nb_ostreams += os->nb_streams;
2048
    }
2049
    if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
2050
        fprintf(stderr, "Number of stream maps must match number of output streams\n");
2051
        ret = AVERROR(EINVAL);
2052
        goto fail;
2053
    }
2054

    
2055
    /* Sanity check the mapping args -- do the input files & streams exist? */
2056
    for(i=0;i<nb_stream_maps;i++) {
2057
        int fi = stream_maps[i].file_index;
2058
        int si = stream_maps[i].stream_index;
2059

    
2060
        if (fi < 0 || fi > nb_input_files - 1 ||
2061
            si < 0 || si > file_table[fi].nb_streams - 1) {
2062
            fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
2063
            ret = AVERROR(EINVAL);
2064
            goto fail;
2065
        }
2066
        fi = stream_maps[i].sync_file_index;
2067
        si = stream_maps[i].sync_stream_index;
2068
        if (fi < 0 || fi > nb_input_files - 1 ||
2069
            si < 0 || si > file_table[fi].nb_streams - 1) {
2070
            fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
2071
            ret = AVERROR(EINVAL);
2072
            goto fail;
2073
        }
2074
    }
2075

    
2076
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2077
    if (!ost_table)
2078
        goto fail;
2079

    
2080
    for(k=0;k<nb_output_files;k++) {
2081
        os = output_files[k];
2082
        for(i=0;i<os->nb_streams;i++,n++) {
2083
            nb_streams[os->streams[i]->codec->codec_type]++;
2084
        }
2085
    }
2086
    for(step=1<<30; step; step>>=1){
2087
        int found_streams[AVMEDIA_TYPE_NB]={0};
2088
        for(j=0; j<AVMEDIA_TYPE_NB; j++)
2089
            nb_frame_threshold[j] += step;
2090

    
2091
        for(j=0; j<nb_istreams; j++) {
2092
            int skip=0;
2093
            ist = ist_table[j];
2094
            if(opt_programid){
2095
                int pi,si;
2096
                AVFormatContext *f= input_files[ ist->file_index ];
2097
                skip=1;
2098
                for(pi=0; pi<f->nb_programs; pi++){
2099
                    AVProgram *p= f->programs[pi];
2100
                    if(p->id == opt_programid)
2101
                        for(si=0; si<p->nb_stream_indexes; si++){
2102
                            if(f->streams[ p->stream_index[si] ] == ist->st)
2103
                                skip=0;
2104
                        }
2105
                }
2106
            }
2107
            if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip
2108
                && nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames){
2109
                found_streams[ist->st->codec->codec_type]++;
2110
            }
2111
        }
2112
        for(j=0; j<AVMEDIA_TYPE_NB; j++)
2113
            if(found_streams[j] < nb_streams[j])
2114
                nb_frame_threshold[j] -= step;
2115
    }
2116
    n = 0;
2117
    for(k=0;k<nb_output_files;k++) {
2118
        os = output_files[k];
2119
        for(i=0;i<os->nb_streams;i++,n++) {
2120
            int found;
2121
            ost = ost_table[n] = output_streams_for_file[k][i];
2122
            ost->st = os->streams[i];
2123
            if (nb_stream_maps > 0) {
2124
                ost->source_index = file_table[stream_maps[n].file_index].ist_index +
2125
                    stream_maps[n].stream_index;
2126

    
2127
                /* Sanity check that the stream types match */
2128
                if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
2129
                    int i= ost->file_index;
2130
                    av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2131
                    fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2132
                        stream_maps[n].file_index, stream_maps[n].stream_index,
2133
                        ost->file_index, ost->index);
2134
                    ffmpeg_exit(1);
2135
                }
2136

    
2137
            } else {
2138
                /* get corresponding input stream index : we select the first one with the right type */
2139
                found = 0;
2140
                for(j=0;j<nb_istreams;j++) {
2141
                    int skip=0;
2142
                    ist = ist_table[j];
2143
                    if(opt_programid){
2144
                        int pi,si;
2145
                        AVFormatContext *f= input_files[ ist->file_index ];
2146
                        skip=1;
2147
                        for(pi=0; pi<f->nb_programs; pi++){
2148
                            AVProgram *p= f->programs[pi];
2149
                            if(p->id == opt_programid)
2150
                                for(si=0; si<p->nb_stream_indexes; si++){
2151
                                    if(f->streams[ p->stream_index[si] ] == ist->st)
2152
                                        skip=0;
2153
                                }
2154
                        }
2155
                    }
2156
                    if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2157
                        ist->st->codec->codec_type == ost->st->codec->codec_type &&
2158
                        nb_frame_threshold[ist->st->codec->codec_type] <= ist->st->codec_info_nb_frames) {
2159
                            ost->source_index = j;
2160
                            found = 1;
2161
                            break;
2162
                    }
2163
                }
2164

    
2165
                if (!found) {
2166
                    if(! opt_programid) {
2167
                        /* try again and reuse existing stream */
2168
                        for(j=0;j<nb_istreams;j++) {
2169
                            ist = ist_table[j];
2170
                            if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2171
                                && ist->st->discard != AVDISCARD_ALL) {
2172
                                ost->source_index = j;
2173
                                found = 1;
2174
                            }
2175
                        }
2176
                    }
2177
                    if (!found) {
2178
                        int i= ost->file_index;
2179
                        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2180
                        fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2181
                                ost->file_index, ost->index);
2182
                        ffmpeg_exit(1);
2183
                    }
2184
                }
2185
            }
2186
            ist = ist_table[ost->source_index];
2187
            ist->discard = 0;
2188
            ost->sync_ist = (nb_stream_maps > 0) ?
2189
                ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2190
                         stream_maps[n].sync_stream_index] : ist;
2191
        }
2192
    }
2193

    
2194
    /* for each output stream, we compute the right encoding parameters */
2195
    for(i=0;i<nb_ostreams;i++) {
2196
        ost = ost_table[i];
2197
        os = output_files[ost->file_index];
2198
        ist = ist_table[ost->source_index];
2199

    
2200
        codec = ost->st->codec;
2201
        icodec = ist->st->codec;
2202

    
2203
        if (metadata_streams_autocopy)
2204
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2205
                             AV_METADATA_DONT_OVERWRITE);
2206

    
2207
        ost->st->disposition = ist->st->disposition;
2208
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2209
        codec->chroma_sample_location = icodec->chroma_sample_location;
2210

    
2211
        if (ost->st->stream_copy) {
2212
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2213

    
2214
            if (extra_size > INT_MAX)
2215
                goto fail;
2216

    
2217
            /* if stream_copy is selected, no need to decode or encode */
2218
            codec->codec_id = icodec->codec_id;
2219
            codec->codec_type = icodec->codec_type;
2220

    
2221
            if(!codec->codec_tag){
2222
                if(   !os->oformat->codec_tag
2223
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2224
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2225
                    codec->codec_tag = icodec->codec_tag;
2226
            }
2227

    
2228
            codec->bit_rate = icodec->bit_rate;
2229
            codec->rc_max_rate    = icodec->rc_max_rate;
2230
            codec->rc_buffer_size = icodec->rc_buffer_size;
2231
            codec->extradata= av_mallocz(extra_size);
2232
            if (!codec->extradata)
2233
                goto fail;
2234
            memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2235
            codec->extradata_size= icodec->extradata_size;
2236
            if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2237
                codec->time_base = icodec->time_base;
2238
                codec->time_base.num *= icodec->ticks_per_frame;
2239
                av_reduce(&codec->time_base.num, &codec->time_base.den,
2240
                          codec->time_base.num, codec->time_base.den, INT_MAX);
2241
            }else
2242
                codec->time_base = ist->st->time_base;
2243
            switch(codec->codec_type) {
2244
            case AVMEDIA_TYPE_AUDIO:
2245
                if(audio_volume != 256) {
2246
                    fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2247
                    ffmpeg_exit(1);
2248
                }
2249
                codec->channel_layout = icodec->channel_layout;
2250
                codec->sample_rate = icodec->sample_rate;
2251
                codec->channels = icodec->channels;
2252
                codec->frame_size = icodec->frame_size;
2253
                codec->audio_service_type = icodec->audio_service_type;
2254
                codec->block_align= icodec->block_align;
2255
                if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2256
                    codec->block_align= 0;
2257
                if(codec->codec_id == CODEC_ID_AC3)
2258
                    codec->block_align= 0;
2259
                break;
2260
            case AVMEDIA_TYPE_VIDEO:
2261
                codec->pix_fmt = icodec->pix_fmt;
2262
                codec->width = icodec->width;
2263
                codec->height = icodec->height;
2264
                codec->has_b_frames = icodec->has_b_frames;
2265
                if (!codec->sample_aspect_ratio.num) {
2266
                    codec->sample_aspect_ratio =
2267
                    ost->st->sample_aspect_ratio =
2268
                        ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2269
                        ist->st->codec->sample_aspect_ratio.num ?
2270
                        ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2271
                }
2272
                break;
2273
            case AVMEDIA_TYPE_SUBTITLE:
2274
                codec->width = icodec->width;
2275
                codec->height = icodec->height;
2276
                break;
2277
            case AVMEDIA_TYPE_DATA:
2278
                break;
2279
            default:
2280
                abort();
2281
            }
2282
        } else {
2283
            switch(codec->codec_type) {
2284
            case AVMEDIA_TYPE_AUDIO:
2285
                ost->fifo= av_fifo_alloc(1024);
2286
                if(!ost->fifo)
2287
                    goto fail;
2288
                ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2289
                ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2290
                icodec->request_channels = codec->channels;
2291
                ist->decoding_needed = 1;
2292
                ost->encoding_needed = 1;
2293
                ost->resample_sample_fmt  = icodec->sample_fmt;
2294
                ost->resample_sample_rate = icodec->sample_rate;
2295
                ost->resample_channels    = icodec->channels;
2296
                break;
2297
            case AVMEDIA_TYPE_VIDEO:
2298
                if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2299
                    fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2300
                    ffmpeg_exit(1);
2301
                }
2302
                ost->video_resample = codec->width   != icodec->width  ||
2303
                                      codec->height  != icodec->height ||
2304
                                      codec->pix_fmt != icodec->pix_fmt;
2305
                if (ost->video_resample) {
2306
                    codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2307
                }
2308
                ost->resample_height = icodec->height;
2309
                ost->resample_width  = icodec->width;
2310
                ost->resample_pix_fmt= icodec->pix_fmt;
2311
                ost->encoding_needed = 1;
2312
                ist->decoding_needed = 1;
2313

    
2314
#if CONFIG_AVFILTER
2315
                if (configure_video_filters(ist, ost)) {
2316
                    fprintf(stderr, "Error opening filters!\n");
2317
                    exit(1);
2318
                }
2319
#endif
2320
                break;
2321
            case AVMEDIA_TYPE_SUBTITLE:
2322
                ost->encoding_needed = 1;
2323
                ist->decoding_needed = 1;
2324
                break;
2325
            default:
2326
                abort();
2327
                break;
2328
            }
2329
            /* two pass mode */
2330
            if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2331
                (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2332
                char logfilename[1024];
2333
                FILE *f;
2334

    
2335
                snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2336
                         pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2337
                         i);
2338
                if (codec->flags & CODEC_FLAG_PASS1) {
2339
                    f = fopen(logfilename, "wb");
2340
                    if (!f) {
2341
                        fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2342
                        ffmpeg_exit(1);
2343
                    }
2344
                    ost->logfile = f;
2345
                } else {
2346
                    char  *logbuffer;
2347
                    size_t logbuffer_size;
2348
                    if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2349
                        fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2350
                        ffmpeg_exit(1);
2351
                    }
2352
                    codec->stats_in = logbuffer;
2353
                }
2354
            }
2355
        }
2356
        if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2357
            /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2358
            int size= codec->width * codec->height;
2359
            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2360
        }
2361
    }
2362

    
2363
    if (!bit_buffer)
2364
        bit_buffer = av_malloc(bit_buffer_size);
2365
    if (!bit_buffer) {
2366
        fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2367
                bit_buffer_size);
2368
        ret = AVERROR(ENOMEM);
2369
        goto fail;
2370
    }
2371

    
2372
    /* open each encoder */
2373
    for(i=0;i<nb_ostreams;i++) {
2374
        ost = ost_table[i];
2375
        if (ost->encoding_needed) {
2376
            AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2377
            AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2378
            if (!codec)
2379
                codec = avcodec_find_encoder(ost->st->codec->codec_id);
2380
            if (!codec) {
2381
                snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2382
                         ost->st->codec->codec_id, ost->file_index, ost->index);
2383
                ret = AVERROR(EINVAL);
2384
                goto dump_format;
2385
            }
2386
            if (dec->subtitle_header) {
2387
                ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2388
                if (!ost->st->codec->subtitle_header) {
2389
                    ret = AVERROR(ENOMEM);
2390
                    goto dump_format;
2391
                }
2392
                memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2393
                ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2394
            }
2395
            if (avcodec_open(ost->st->codec, codec) < 0) {
2396
                snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2397
                        ost->file_index, ost->index);
2398
                ret = AVERROR(EINVAL);
2399
                goto dump_format;
2400
            }
2401
            extra_size += ost->st->codec->extradata_size;
2402
        }
2403
    }
2404

    
2405
    /* open each decoder */
2406
    for(i=0;i<nb_istreams;i++) {
2407
        ist = ist_table[i];
2408
        if (ist->decoding_needed) {
2409
            AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2410
            if (!codec)
2411
                codec = avcodec_find_decoder(ist->st->codec->codec_id);
2412
            if (!codec) {
2413
                snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2414
                        ist->st->codec->codec_id, ist->file_index, ist->index);
2415
                ret = AVERROR(EINVAL);
2416
                goto dump_format;
2417
            }
2418
            if (avcodec_open(ist->st->codec, codec) < 0) {
2419
                snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2420
                        ist->file_index, ist->index);
2421
                ret = AVERROR(EINVAL);
2422
                goto dump_format;
2423
            }
2424
            //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2425
            //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2426
        }
2427
    }
2428

    
2429
    /* init pts */
2430
    for(i=0;i<nb_istreams;i++) {
2431
        AVStream *st;
2432
        ist = ist_table[i];
2433
        st= ist->st;
2434
        ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2435
        ist->next_pts = AV_NOPTS_VALUE;
2436
        ist->is_start = 1;
2437
    }
2438

    
2439
    /* set meta data information from input file if required */
2440
    for (i=0;i<nb_meta_data_maps;i++) {
2441
        AVFormatContext *files[2];
2442
        AVMetadata      **meta[2];
2443
        int j;
2444

    
2445
#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2446
        if ((index) < 0 || (index) >= (nb_elems)) {\
2447
            snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2448
                     (desc), (index));\
2449
            ret = AVERROR(EINVAL);\
2450
            goto dump_format;\
2451
        }
2452

    
2453
        int out_file_index = meta_data_maps[i][0].file;
2454
        int in_file_index = meta_data_maps[i][1].file;
2455
        if (in_file_index < 0 || out_file_index < 0)
2456
            continue;
2457
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2458
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2459

    
2460
        files[0] = output_files[out_file_index];
2461
        files[1] = input_files[in_file_index];
2462

    
2463
        for (j = 0; j < 2; j++) {
2464
            AVMetaDataMap *map = &meta_data_maps[i][j];
2465

    
2466
            switch (map->type) {
2467
            case 'g':
2468
                meta[j] = &files[j]->metadata;
2469
                break;
2470
            case 's':
2471
                METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2472
                meta[j] = &files[j]->streams[map->index]->metadata;
2473
                break;
2474
            case 'c':
2475
                METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2476
                meta[j] = &files[j]->chapters[map->index]->metadata;
2477
                break;
2478
            case 'p':
2479
                METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2480
                meta[j] = &files[j]->programs[map->index]->metadata;
2481
                break;
2482
            }
2483
        }
2484

    
2485
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2486
    }
2487

    
2488
    /* copy global metadata by default */
2489
    if (metadata_global_autocopy) {
2490

    
2491
        for (i = 0; i < nb_output_files; i++)
2492
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2493
                             AV_METADATA_DONT_OVERWRITE);
2494
    }
2495

    
2496
    /* copy chapters according to chapter maps */
2497
    for (i = 0; i < nb_chapter_maps; i++) {
2498
        int infile  = chapter_maps[i].in_file;
2499
        int outfile = chapter_maps[i].out_file;
2500

    
2501
        if (infile < 0 || outfile < 0)
2502
            continue;
2503
        if (infile >= nb_input_files) {
2504
            snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2505
            ret = AVERROR(EINVAL);
2506
            goto dump_format;
2507
        }
2508
        if (outfile >= nb_output_files) {
2509
            snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2510
            ret = AVERROR(EINVAL);
2511
            goto dump_format;
2512
        }
2513
        copy_chapters(infile, outfile);
2514
    }
2515

    
2516
    /* copy chapters from the first input file that has them*/
2517
    if (!nb_chapter_maps)
2518
        for (i = 0; i < nb_input_files; i++) {
2519
            if (!input_files[i]->nb_chapters)
2520
                continue;
2521

    
2522
            for (j = 0; j < nb_output_files; j++)
2523
                if ((ret = copy_chapters(i, j)) < 0)
2524
                    goto dump_format;
2525
            break;
2526
        }
2527

    
2528
    /* open files and write file headers */
2529
    for(i=0;i<nb_output_files;i++) {
2530
        os = output_files[i];
2531
        if (av_write_header(os) < 0) {
2532
            snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2533
            ret = AVERROR(EINVAL);
2534
            goto dump_format;
2535
        }
2536
        if (strcmp(output_files[i]->oformat->name, "rtp")) {
2537
            want_sdp = 0;
2538
        }
2539
    }
2540

    
2541
 dump_format:
2542
    /* dump the file output parameters - cannot be done before in case
2543
       of stream copy */
2544
    for(i=0;i<nb_output_files;i++) {
2545
        av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2546
    }
2547

    
2548
    /* dump the stream mapping */
2549
    if (verbose >= 0) {
2550
        fprintf(stderr, "Stream mapping:\n");
2551
        for(i=0;i<nb_ostreams;i++) {
2552
            ost = ost_table[i];
2553
            fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2554
                    ist_table[ost->source_index]->file_index,
2555
                    ist_table[ost->source_index]->index,
2556
                    ost->file_index,
2557
                    ost->index);
2558
            if (ost->sync_ist != ist_table[ost->source_index])
2559
                fprintf(stderr, " [sync #%d.%d]",
2560
                        ost->sync_ist->file_index,
2561
                        ost->sync_ist->index);
2562
            fprintf(stderr, "\n");
2563
        }
2564
    }
2565

    
2566
    if (ret) {
2567
        fprintf(stderr, "%s\n", error);
2568
        goto fail;
2569
    }
2570

    
2571
    if (want_sdp) {
2572
        print_sdp(output_files, nb_output_files);
2573
    }
2574

    
2575
    if (!using_stdin) {
2576
        if(verbose >= 0)
2577
            fprintf(stderr, "Press [q] to stop encoding\n");
2578
        avio_set_interrupt_cb(decode_interrupt_cb);
2579
    }
2580
    term_init();
2581

    
2582
    timer_start = av_gettime();
2583

    
2584
    for(; received_sigterm == 0;) {
2585
        int file_index, ist_index;
2586
        AVPacket pkt;
2587
        double ipts_min;
2588
        double opts_min;
2589

    
2590
    redo:
2591
        ipts_min= 1e100;
2592
        opts_min= 1e100;
2593
        /* if 'q' pressed, exits */
2594
        if (!using_stdin) {
2595
            if (q_pressed)
2596
                break;
2597
            /* read_key() returns 0 on EOF */
2598
            key = read_key();
2599
            if (key == 'q')
2600
                break;
2601
        }
2602

    
2603
        /* select the stream that we must read now by looking at the
2604
           smallest output pts */
2605
        file_index = -1;
2606
        for(i=0;i<nb_ostreams;i++) {
2607
            double ipts, opts;
2608
            ost = ost_table[i];
2609
            os = output_files[ost->file_index];
2610
            ist = ist_table[ost->source_index];
2611
            if(ist->is_past_recording_time || no_packet[ist->file_index])
2612
                continue;
2613
                opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2614
            ipts = (double)ist->pts;
2615
            if (!file_table[ist->file_index].eof_reached){
2616
                if(ipts < ipts_min) {
2617
                    ipts_min = ipts;
2618
                    if(input_sync ) file_index = ist->file_index;
2619
                }
2620
                if(opts < opts_min) {
2621
                    opts_min = opts;
2622
                    if(!input_sync) file_index = ist->file_index;
2623
                }
2624
            }
2625
            if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2626
                file_index= -1;
2627
                break;
2628
            }
2629
        }
2630
        /* if none, if is finished */
2631
        if (file_index < 0) {
2632
            if(no_packet_count){
2633
                no_packet_count=0;
2634
                memset(no_packet, 0, sizeof(no_packet));
2635
                usleep(10000);
2636
                continue;
2637
            }
2638
            break;
2639
        }
2640

    
2641
        /* finish if limit size exhausted */
2642
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2643
            break;
2644

    
2645
        /* read a frame from it and output it in the fifo */
2646
        is = input_files[file_index];
2647
        ret= av_read_frame(is, &pkt);
2648
        if(ret == AVERROR(EAGAIN)){
2649
            no_packet[file_index]=1;
2650
            no_packet_count++;
2651
            continue;
2652
        }
2653
        if (ret < 0) {
2654
            file_table[file_index].eof_reached = 1;
2655
            if (opt_shortest)
2656
                break;
2657
            else
2658
                continue;
2659
        }
2660

    
2661
        no_packet_count=0;
2662
        memset(no_packet, 0, sizeof(no_packet));
2663

    
2664
        if (do_pkt_dump) {
2665
            av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2666
                             is->streams[pkt.stream_index]);
2667
        }
2668
        /* the following test is needed in case new streams appear
2669
           dynamically in stream : we ignore them */
2670
        if (pkt.stream_index >= file_table[file_index].nb_streams)
2671
            goto discard_packet;
2672
        ist_index = file_table[file_index].ist_index + pkt.stream_index;
2673
        ist = ist_table[ist_index];
2674
        if (ist->discard)
2675
            goto discard_packet;
2676

    
2677
        if (pkt.dts != AV_NOPTS_VALUE)
2678
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2679
        if (pkt.pts != AV_NOPTS_VALUE)
2680
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2681

    
2682
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2683
            && input_files_ts_scale[file_index][pkt.stream_index]){
2684
            if(pkt.pts != AV_NOPTS_VALUE)
2685
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2686
            if(pkt.dts != AV_NOPTS_VALUE)
2687
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2688
        }
2689

    
2690
//        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);
2691
        if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2692
            && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2693
            int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2694
            int64_t delta= pkt_dts - ist->next_pts;
2695
            if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2696
                input_files_ts_offset[ist->file_index]-= delta;
2697
                if (verbose > 2)
2698
                    fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2699
                pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2700
                if(pkt.pts != AV_NOPTS_VALUE)
2701
                    pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2702
            }
2703
        }
2704

    
2705
        /* finish if recording time exhausted */
2706
        if (recording_time != INT64_MAX &&
2707
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2708
            ist->is_past_recording_time = 1;
2709
            goto discard_packet;
2710
        }
2711

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

    
2715
            if (verbose >= 0)
2716
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2717
                        ist->file_index, ist->index);
2718
            if (exit_on_error)
2719
                ffmpeg_exit(1);
2720
            av_free_packet(&pkt);
2721
            goto redo;
2722
        }
2723

    
2724
    discard_packet:
2725
        av_free_packet(&pkt);
2726

    
2727
        /* dump report by using the output first video and audio streams */
2728
        print_report(output_files, ost_table, nb_ostreams, 0);
2729
    }
2730

    
2731
    /* at the end of stream, we must flush the decoder buffers */
2732
    for(i=0;i<nb_istreams;i++) {
2733
        ist = ist_table[i];
2734
        if (ist->decoding_needed) {
2735
            output_packet(ist, i, ost_table, nb_ostreams, NULL);
2736
        }
2737
    }
2738

    
2739
    term_exit();
2740

    
2741
    /* write the trailer if needed and close file */
2742
    for(i=0;i<nb_output_files;i++) {
2743
        os = output_files[i];
2744
        av_write_trailer(os);
2745
    }
2746

    
2747
    /* dump report by using the first video and audio streams */
2748
    print_report(output_files, ost_table, nb_ostreams, 1);
2749

    
2750
    /* close each encoder */
2751
    for(i=0;i<nb_ostreams;i++) {
2752
        ost = ost_table[i];
2753
        if (ost->encoding_needed) {
2754
            av_freep(&ost->st->codec->stats_in);
2755
            avcodec_close(ost->st->codec);
2756
        }
2757
#if CONFIG_AVFILTER
2758
        avfilter_graph_free(&ost->graph);
2759
#endif
2760
    }
2761

    
2762
    /* close each decoder */
2763
    for(i=0;i<nb_istreams;i++) {
2764
        ist = ist_table[i];
2765
        if (ist->decoding_needed) {
2766
            avcodec_close(ist->st->codec);
2767
        }
2768
    }
2769

    
2770
    /* finished ! */
2771
    ret = 0;
2772

    
2773
 fail:
2774
    av_freep(&bit_buffer);
2775
    av_free(file_table);
2776

    
2777
    if (ist_table) {
2778
        for(i=0;i<nb_istreams;i++) {
2779
            ist = ist_table[i];
2780
            av_free(ist);
2781
        }
2782
        av_free(ist_table);
2783
    }
2784
    if (ost_table) {
2785
        for(i=0;i<nb_ostreams;i++) {
2786
            ost = ost_table[i];
2787
            if (ost) {
2788
                if (ost->st->stream_copy)
2789
                    av_freep(&ost->st->codec->extradata);
2790
                if (ost->logfile) {
2791
                    fclose(ost->logfile);
2792
                    ost->logfile = NULL;
2793
                }
2794
                av_fifo_free(ost->fifo); /* works even if fifo is not
2795
                                             initialized but set to zero */
2796
                av_freep(&ost->st->codec->subtitle_header);
2797
                av_free(ost->pict_tmp.data[0]);
2798
                av_free(ost->forced_kf_pts);
2799
                if (ost->video_resample)
2800
                    sws_freeContext(ost->img_resample_ctx);
2801
                if (ost->resample)
2802
                    audio_resample_close(ost->resample);
2803
                if (ost->reformat_ctx)
2804
                    av_audio_convert_free(ost->reformat_ctx);
2805
                av_free(ost);
2806
            }
2807
        }
2808
        av_free(ost_table);
2809
    }
2810
    return ret;
2811
}
2812

    
2813
static void opt_format(const char *arg)
2814
{
2815
    last_asked_format = arg;
2816
}
2817

    
2818
static void opt_video_rc_override_string(const char *arg)
2819
{
2820
    video_rc_override_string = arg;
2821
}
2822

    
2823
static int opt_me_threshold(const char *opt, const char *arg)
2824
{
2825
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2826
    return 0;
2827
}
2828

    
2829
static int opt_verbose(const char *opt, const char *arg)
2830
{
2831
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2832
    return 0;
2833
}
2834

    
2835
static int opt_frame_rate(const char *opt, const char *arg)
2836
{
2837
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2838
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2839
        ffmpeg_exit(1);
2840
    }
2841
    return 0;
2842
}
2843

    
2844
static int opt_bitrate(const char *opt, const char *arg)
2845
{
2846
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2847

    
2848
    opt_default(opt, arg);
2849

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

    
2853
    return 0;
2854
}
2855

    
2856
static int opt_frame_crop(const char *opt, const char *arg)
2857
{
2858
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2859
    return AVERROR(EINVAL);
2860
}
2861

    
2862
static void opt_frame_size(const char *arg)
2863
{
2864
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2865
        fprintf(stderr, "Incorrect frame size\n");
2866
        ffmpeg_exit(1);
2867
    }
2868
}
2869

    
2870
static int opt_pad(const char *opt, const char *arg) {
2871
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2872
    return -1;
2873
}
2874

    
2875
static void opt_frame_pix_fmt(const char *arg)
2876
{
2877
    if (strcmp(arg, "list")) {
2878
        frame_pix_fmt = av_get_pix_fmt(arg);
2879
        if (frame_pix_fmt == PIX_FMT_NONE) {
2880
            fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2881
            ffmpeg_exit(1);
2882
        }
2883
    } else {
2884
        show_pix_fmts();
2885
        ffmpeg_exit(0);
2886
    }
2887
}
2888

    
2889
static void opt_frame_aspect_ratio(const char *arg)
2890
{
2891
    int x = 0, y = 0;
2892
    double ar = 0;
2893
    const char *p;
2894
    char *end;
2895

    
2896
    p = strchr(arg, ':');
2897
    if (p) {
2898
        x = strtol(arg, &end, 10);
2899
        if (end == p)
2900
            y = strtol(end+1, &end, 10);
2901
        if (x > 0 && y > 0)
2902
            ar = (double)x / (double)y;
2903
    } else
2904
        ar = strtod(arg, NULL);
2905

    
2906
    if (!ar) {
2907
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2908
        ffmpeg_exit(1);
2909
    }
2910
    frame_aspect_ratio = ar;
2911
}
2912

    
2913
static int opt_metadata(const char *opt, const char *arg)
2914
{
2915
    char *mid= strchr(arg, '=');
2916

    
2917
    if(!mid){
2918
        fprintf(stderr, "Missing =\n");
2919
        ffmpeg_exit(1);
2920
    }
2921
    *mid++= 0;
2922

    
2923
    av_metadata_set2(&metadata, arg, mid, 0);
2924

    
2925
    return 0;
2926
}
2927

    
2928
static int opt_qscale(const char *opt, const char *arg)
2929
{
2930
    video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2931
    if (video_qscale <= 0 || video_qscale > 255) {
2932
        fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2933
        return AVERROR(EINVAL);
2934
    }
2935
    return 0;
2936
}
2937

    
2938
static int opt_top_field_first(const char *opt, const char *arg)
2939
{
2940
    top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2941
    return 0;
2942
}
2943

    
2944
static int opt_thread_count(const char *opt, const char *arg)
2945
{
2946
    thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2947
#if !HAVE_THREADS
2948
    if (verbose >= 0)
2949
        fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2950
#endif
2951
    return 0;
2952
}
2953

    
2954
static void opt_audio_sample_fmt(const char *arg)
2955
{
2956
    if (strcmp(arg, "list")) {
2957
        audio_sample_fmt = av_get_sample_fmt(arg);
2958
        if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2959
            av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2960
            ffmpeg_exit(1);
2961
        }
2962
    } else {
2963
        int i;
2964
        char fmt_str[128];
2965
        for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2966
            printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2967
        ffmpeg_exit(0);
2968
    }
2969
}
2970

    
2971
static int opt_audio_rate(const char *opt, const char *arg)
2972
{
2973
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2974
    return 0;
2975
}
2976

    
2977
static int opt_audio_channels(const char *opt, const char *arg)
2978
{
2979
    audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2980
    return 0;
2981
}
2982

    
2983
static int opt_video_channel(const char *opt, const char *arg)
2984
{
2985
    video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2986
    return 0;
2987
}
2988

    
2989
static void opt_video_standard(const char *arg)
2990
{
2991
    video_standard = av_strdup(arg);
2992
}
2993

    
2994
static void opt_codec(int *pstream_copy, char **pcodec_name,
2995
                      int codec_type, const char *arg)
2996
{
2997
    av_freep(pcodec_name);
2998
    if (!strcmp(arg, "copy")) {
2999
        *pstream_copy = 1;
3000
    } else {
3001
        *pcodec_name = av_strdup(arg);
3002
    }
3003
}
3004

    
3005
static void opt_audio_codec(const char *arg)
3006
{
3007
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
3008
}
3009

    
3010
static void opt_video_codec(const char *arg)
3011
{
3012
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
3013
}
3014

    
3015
static void opt_subtitle_codec(const char *arg)
3016
{
3017
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3018
}
3019

    
3020
static void opt_data_codec(const char *arg)
3021
{
3022
    opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
3023
}
3024

    
3025
static int opt_codec_tag(const char *opt, const char *arg)
3026
{
3027
    char *tail;
3028
    uint32_t *codec_tag;
3029

    
3030
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3031
                !strcmp(opt, "vtag") ? &video_codec_tag :
3032
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3033
    if (!codec_tag)
3034
        return -1;
3035

    
3036
    *codec_tag = strtol(arg, &tail, 0);
3037
    if (!tail || *tail)
3038
        *codec_tag = AV_RL32(arg);
3039

    
3040
    return 0;
3041
}
3042

    
3043
static void opt_map(const char *arg)
3044
{
3045
    AVStreamMap *m;
3046
    char *p;
3047

    
3048
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3049
    m = &stream_maps[nb_stream_maps-1];
3050

    
3051
    m->file_index = strtol(arg, &p, 0);
3052
    if (*p)
3053
        p++;
3054

    
3055
    m->stream_index = strtol(p, &p, 0);
3056
    if (*p) {
3057
        p++;
3058
        m->sync_file_index = strtol(p, &p, 0);
3059
        if (*p)
3060
            p++;
3061
        m->sync_stream_index = strtol(p, &p, 0);
3062
    } else {
3063
        m->sync_file_index = m->file_index;
3064
        m->sync_stream_index = m->stream_index;
3065
    }
3066
}
3067

    
3068
static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
3069
{
3070
    *endptr = arg;
3071
    if (*arg == ',') {
3072
        *type = *(++arg);
3073
        switch (*arg) {
3074
        case 'g':
3075
            break;
3076
        case 's':
3077
        case 'c':
3078
        case 'p':
3079
            *index = strtol(++arg, endptr, 0);
3080
            break;
3081
        default:
3082
            fprintf(stderr, "Invalid metadata type %c.\n", *arg);
3083
            ffmpeg_exit(1);
3084
        }
3085
    } else
3086
        *type = 'g';
3087
}
3088

    
3089
static void opt_map_metadata(const char *arg)
3090
{
3091
    AVMetaDataMap *m, *m1;
3092
    char *p;
3093

    
3094
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3095
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3096

    
3097
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3098
    m->file = strtol(arg, &p, 0);
3099
    parse_meta_type(p, &m->type, &m->index, &p);
3100
    if (*p)
3101
        p++;
3102

    
3103
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3104
    m1->file = strtol(p, &p, 0);
3105
    parse_meta_type(p, &m1->type, &m1->index, &p);
3106

    
3107
    if (m->type == 'g' || m1->type == 'g')
3108
        metadata_global_autocopy = 0;
3109
    if (m->type == 's' || m1->type == 's')
3110
        metadata_streams_autocopy = 0;
3111
    if (m->type == 'c' || m1->type == 'c')
3112
        metadata_chapters_autocopy = 0;
3113
}
3114

    
3115
static void opt_map_meta_data(const char *arg)
3116
{
3117
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3118
                    "Use -map_metadata instead.\n");
3119
    opt_map_metadata(arg);
3120
}
3121

    
3122
static void opt_map_chapters(const char *arg)
3123
{
3124
    AVChapterMap *c;
3125
    char *p;
3126

    
3127
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3128
                              nb_chapter_maps + 1);
3129
    c = &chapter_maps[nb_chapter_maps - 1];
3130
    c->out_file = strtol(arg, &p, 0);
3131
    if (*p)
3132
        p++;
3133

    
3134
    c->in_file = strtol(p, &p, 0);
3135
}
3136

    
3137
static void opt_input_ts_scale(const char *arg)
3138
{
3139
    unsigned int stream;
3140
    double scale;
3141
    char *p;
3142

    
3143
    stream = strtol(arg, &p, 0);
3144
    if (*p)
3145
        p++;
3146
    scale= strtod(p, &p);
3147

    
3148
    if(stream >= MAX_STREAMS)
3149
        ffmpeg_exit(1);
3150

    
3151
    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);
3152
    input_files_ts_scale[nb_input_files][stream]= scale;
3153
}
3154

    
3155
static int opt_recording_time(const char *opt, const char *arg)
3156
{
3157
    recording_time = parse_time_or_die(opt, arg, 1);
3158
    return 0;
3159
}
3160

    
3161
static int opt_start_time(const char *opt, const char *arg)
3162
{
3163
    start_time = parse_time_or_die(opt, arg, 1);
3164
    return 0;
3165
}
3166

    
3167
static int opt_recording_timestamp(const char *opt, const char *arg)
3168
{
3169
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3170
    return 0;
3171
}
3172

    
3173
static int opt_input_ts_offset(const char *opt, const char *arg)
3174
{
3175
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3176
    return 0;
3177
}
3178

    
3179
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3180
{
3181
    const char *codec_string = encoder ? "encoder" : "decoder";
3182
    AVCodec *codec;
3183

    
3184
    if(!name)
3185
        return CODEC_ID_NONE;
3186
    codec = encoder ?
3187
        avcodec_find_encoder_by_name(name) :
3188
        avcodec_find_decoder_by_name(name);
3189
    if(!codec) {
3190
        fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3191
        ffmpeg_exit(1);
3192
    }
3193
    if(codec->type != type) {
3194
        fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3195
        ffmpeg_exit(1);
3196
    }
3197
    if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3198
       strict > FF_COMPLIANCE_EXPERIMENTAL) {
3199
        fprintf(stderr, "%s '%s' is experimental and might produce bad "
3200
                "results.\nAdd '-strict experimental' if you want to use it.\n",
3201
                codec_string, codec->name);
3202
        codec = encoder ?
3203
            avcodec_find_encoder(codec->id) :
3204
            avcodec_find_decoder(codec->id);
3205
        if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3206
            fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3207
                    codec_string, codec->name);
3208
        ffmpeg_exit(1);
3209
    }
3210
    return codec->id;
3211
}
3212

    
3213
static void opt_input_file(const char *filename)
3214
{
3215
    AVFormatContext *ic;
3216
    AVFormatParameters params, *ap = &params;
3217
    AVInputFormat *file_iformat = NULL;
3218
    int err, i, ret, rfps, rfps_base;
3219
    int64_t timestamp;
3220

    
3221
    if (last_asked_format) {
3222
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3223
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3224
            ffmpeg_exit(1);
3225
        }
3226
        last_asked_format = NULL;
3227
    }
3228

    
3229
    if (!strcmp(filename, "-"))
3230
        filename = "pipe:";
3231

    
3232
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3233
                    !strcmp(filename, "/dev/stdin");
3234

    
3235
    /* get default parameters from command line */
3236
    ic = avformat_alloc_context();
3237
    if (!ic) {
3238
        print_error(filename, AVERROR(ENOMEM));
3239
        ffmpeg_exit(1);
3240
    }
3241

    
3242
    memset(ap, 0, sizeof(*ap));
3243
    ap->prealloced_context = 1;
3244
    ap->sample_rate = audio_sample_rate;
3245
    ap->channels = audio_channels;
3246
    ap->time_base.den = frame_rate.num;
3247
    ap->time_base.num = frame_rate.den;
3248
    ap->width = frame_width;
3249
    ap->height = frame_height;
3250
    ap->pix_fmt = frame_pix_fmt;
3251
   // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3252
    ap->channel = video_channel;
3253
    ap->standard = video_standard;
3254

    
3255
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3256

    
3257
    ic->video_codec_id   =
3258
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3259
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3260
    ic->audio_codec_id   =
3261
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3262
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3263
    ic->subtitle_codec_id=
3264
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3265
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3266
    ic->flags |= AVFMT_FLAG_NONBLOCK | AVFMT_FLAG_PRIV_OPT;
3267

    
3268
    /* open the input file with generic libav function */
3269
    err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3270
    if(err >= 0){
3271
        set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3272
        err = av_demuxer_open(ic, ap);
3273
        if(err < 0)
3274
            avformat_free_context(ic);
3275
    }
3276
    if (err < 0) {
3277
        print_error(filename, err);
3278
        ffmpeg_exit(1);
3279
    }
3280
    if(opt_programid) {
3281
        int i, j;
3282
        int found=0;
3283
        for(i=0; i<ic->nb_streams; i++){
3284
            ic->streams[i]->discard= AVDISCARD_ALL;
3285
        }
3286
        for(i=0; i<ic->nb_programs; i++){
3287
            AVProgram *p= ic->programs[i];
3288
            if(p->id != opt_programid){
3289
                p->discard = AVDISCARD_ALL;
3290
            }else{
3291
                found=1;
3292
                for(j=0; j<p->nb_stream_indexes; j++){
3293
                    ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3294
                }
3295
            }
3296
        }
3297
        if(!found){
3298
            fprintf(stderr, "Specified program id not found\n");
3299
            ffmpeg_exit(1);
3300
        }
3301
        opt_programid=0;
3302
    }
3303

    
3304
    ic->loop_input = loop_input;
3305

    
3306
    /* If not enough info to get the stream parameters, we decode the
3307
       first frames to get it. (used in mpeg case for example) */
3308
    ret = av_find_stream_info(ic);
3309
    if (ret < 0 && verbose >= 0) {
3310
        fprintf(stderr, "%s: could not find codec parameters\n", filename);
3311
        av_close_input_file(ic);
3312
        ffmpeg_exit(1);
3313
    }
3314

    
3315
    timestamp = start_time;
3316
    /* add the stream start time */
3317
    if (ic->start_time != AV_NOPTS_VALUE)
3318
        timestamp += ic->start_time;
3319

    
3320
    /* if seeking requested, we execute it */
3321
    if (start_time != 0) {
3322
        ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3323
        if (ret < 0) {
3324
            fprintf(stderr, "%s: could not seek to position %0.3f\n",
3325
                    filename, (double)timestamp / AV_TIME_BASE);
3326
        }
3327
        /* reset seek info */
3328
        start_time = 0;
3329
    }
3330

    
3331
    /* update the current parameters so that they match the one of the input stream */
3332
    for(i=0;i<ic->nb_streams;i++) {
3333
        AVStream *st = ic->streams[i];
3334
        AVCodecContext *dec = st->codec;
3335
        dec->thread_count = thread_count;
3336
        input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3337
        switch (dec->codec_type) {
3338
        case AVMEDIA_TYPE_AUDIO:
3339
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3340
            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]);
3341
            channel_layout    = dec->channel_layout;
3342
            audio_channels    = dec->channels;
3343
            audio_sample_rate = dec->sample_rate;
3344
            audio_sample_fmt  = dec->sample_fmt;
3345
            if(audio_disable)
3346
                st->discard= AVDISCARD_ALL;
3347
            /* Note that av_find_stream_info can add more streams, and we
3348
             * currently have no chance of setting up lowres decoding
3349
             * early enough for them. */
3350
            if (dec->lowres)
3351
                audio_sample_rate >>= dec->lowres;
3352
            break;
3353
        case AVMEDIA_TYPE_VIDEO:
3354
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3355
            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]);
3356
            frame_height = dec->height;
3357
            frame_width  = dec->width;
3358
            frame_pix_fmt = dec->pix_fmt;
3359
            rfps      = ic->streams[i]->r_frame_rate.num;
3360
            rfps_base = ic->streams[i]->r_frame_rate.den;
3361
            if (dec->lowres) {
3362
                dec->flags |= CODEC_FLAG_EMU_EDGE;
3363
                frame_height >>= dec->lowres;
3364
                frame_width  >>= dec->lowres;
3365
                dec->height = frame_height;
3366
                dec->width  = frame_width;
3367
            }
3368
            if(me_threshold)
3369
                dec->debug |= FF_DEBUG_MV;
3370

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

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

    
3377
                    (float)rfps / rfps_base, rfps, rfps_base);
3378
            }
3379
            /* update the current frame rate to match the stream frame rate */
3380
            frame_rate.num = rfps;
3381
            frame_rate.den = rfps_base;
3382

    
3383
            if(video_disable)
3384
                st->discard= AVDISCARD_ALL;
3385
            else if(video_discard)
3386
                st->discard= video_discard;
3387
            break;
3388
        case AVMEDIA_TYPE_DATA:
3389
            break;
3390
        case AVMEDIA_TYPE_SUBTITLE:
3391
            input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3392
            if(subtitle_disable)
3393
                st->discard = AVDISCARD_ALL;
3394
            break;
3395
        case AVMEDIA_TYPE_ATTACHMENT:
3396
        case AVMEDIA_TYPE_UNKNOWN:
3397
            break;
3398
        default:
3399
            abort();
3400
        }
3401
    }
3402

    
3403
    input_files[nb_input_files] = ic;
3404
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3405
    /* dump the file content */
3406
    if (verbose >= 0)
3407
        av_dump_format(ic, nb_input_files, filename, 0);
3408

    
3409
    nb_input_files++;
3410

    
3411
    video_channel = 0;
3412

    
3413
    av_freep(&video_codec_name);
3414
    av_freep(&audio_codec_name);
3415
    av_freep(&subtitle_codec_name);
3416
}
3417

    
3418
static void check_inputs(int *has_video_ptr,
3419
                         int *has_audio_ptr,
3420
                         int *has_subtitle_ptr,
3421
                         int *has_data_ptr)
3422
{
3423
    int has_video, has_audio, has_subtitle, has_data, i, j;
3424
    AVFormatContext *ic;
3425

    
3426
    has_video = 0;
3427
    has_audio = 0;
3428
    has_subtitle = 0;
3429
    has_data = 0;
3430

    
3431
    for(j=0;j<nb_input_files;j++) {
3432
        ic = input_files[j];
3433
        for(i=0;i<ic->nb_streams;i++) {
3434
            AVCodecContext *enc = ic->streams[i]->codec;
3435
            switch(enc->codec_type) {
3436
            case AVMEDIA_TYPE_AUDIO:
3437
                has_audio = 1;
3438
                break;
3439
            case AVMEDIA_TYPE_VIDEO:
3440
                has_video = 1;
3441
                break;
3442
            case AVMEDIA_TYPE_SUBTITLE:
3443
                has_subtitle = 1;
3444
                break;
3445
            case AVMEDIA_TYPE_DATA:
3446
            case AVMEDIA_TYPE_ATTACHMENT:
3447
            case AVMEDIA_TYPE_UNKNOWN:
3448
                has_data = 1;
3449
                break;
3450
            default:
3451
                abort();
3452
            }
3453
        }
3454
    }
3455
    *has_video_ptr = has_video;
3456
    *has_audio_ptr = has_audio;
3457
    *has_subtitle_ptr = has_subtitle;
3458
    *has_data_ptr = has_data;
3459
}
3460

    
3461
static void new_video_stream(AVFormatContext *oc, int file_idx)
3462
{
3463
    AVStream *st;
3464
    AVOutputStream *ost;
3465
    AVCodecContext *video_enc;
3466
    enum CodecID codec_id = CODEC_ID_NONE;
3467
    AVCodec *codec= NULL;
3468

    
3469
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3470
    if (!st) {
3471
        fprintf(stderr, "Could not alloc stream\n");
3472
        ffmpeg_exit(1);
3473
    }
3474
    ost = new_output_stream(oc, file_idx);
3475

    
3476
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3477
    if(!video_stream_copy){
3478
        if (video_codec_name) {
3479
            codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3480
                                         avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3481
            codec = avcodec_find_encoder_by_name(video_codec_name);
3482
            output_codecs[nb_output_codecs-1] = codec;
3483
        } else {
3484
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3485
            codec = avcodec_find_encoder(codec_id);
3486
        }
3487
        ost->frame_aspect_ratio = frame_aspect_ratio;
3488
        frame_aspect_ratio = 0;
3489
#if CONFIG_AVFILTER
3490
        ost->avfilter= vfilters;
3491
        vfilters= NULL;
3492
#endif
3493
    }
3494

    
3495
    avcodec_get_context_defaults3(st->codec, codec);
3496
    ost->bitstream_filters = video_bitstream_filters;
3497
    video_bitstream_filters= NULL;
3498

    
3499
    st->codec->thread_count= thread_count;
3500

    
3501
    video_enc = st->codec;
3502

    
3503
    if(video_codec_tag)
3504
        video_enc->codec_tag= video_codec_tag;
3505

    
3506
    if(   (video_global_header&1)
3507
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3508
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3509
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3510
    }
3511
    if(video_global_header&2){
3512
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3513
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3514
    }
3515

    
3516
    if (video_stream_copy) {
3517
        st->stream_copy = 1;
3518
        video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3519
        video_enc->sample_aspect_ratio =
3520
        st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3521
    } else {
3522
        const char *p;
3523
        int i;
3524
        AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3525

    
3526
        video_enc->codec_id = codec_id;
3527
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3528

    
3529
        if (codec && codec->supported_framerates && !force_fps)
3530
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3531
        video_enc->time_base.den = fps.num;
3532
        video_enc->time_base.num = fps.den;
3533

    
3534
        video_enc->width = frame_width;
3535
        video_enc->height = frame_height;
3536
        video_enc->pix_fmt = frame_pix_fmt;
3537
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3538
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3539

    
3540
        choose_pixel_fmt(st, codec);
3541

    
3542
        if (intra_only)
3543
            video_enc->gop_size = 0;
3544
        if (video_qscale || same_quality) {
3545
            video_enc->flags |= CODEC_FLAG_QSCALE;
3546
            video_enc->global_quality=
3547
                st->quality = FF_QP2LAMBDA * video_qscale;
3548
        }
3549

    
3550
        if(intra_matrix)
3551
            video_enc->intra_matrix = intra_matrix;
3552
        if(inter_matrix)
3553
            video_enc->inter_matrix = inter_matrix;
3554

    
3555
        p= video_rc_override_string;
3556
        for(i=0; p; i++){
3557
            int start, end, q;
3558
            int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3559
            if(e!=3){
3560
                fprintf(stderr, "error parsing rc_override\n");
3561
                ffmpeg_exit(1);
3562
            }
3563
            video_enc->rc_override=
3564
                av_realloc(video_enc->rc_override,
3565
                           sizeof(RcOverride)*(i+1));
3566
            video_enc->rc_override[i].start_frame= start;
3567
            video_enc->rc_override[i].end_frame  = end;
3568
            if(q>0){
3569
                video_enc->rc_override[i].qscale= q;
3570
                video_enc->rc_override[i].quality_factor= 1.0;
3571
            }
3572
            else{
3573
                video_enc->rc_override[i].qscale= 0;
3574
                video_enc->rc_override[i].quality_factor= -q/100.0;
3575
            }
3576
            p= strchr(p, '/');
3577
            if(p) p++;
3578
        }
3579
        video_enc->rc_override_count=i;
3580
        if (!video_enc->rc_initial_buffer_occupancy)
3581
            video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3582
        video_enc->me_threshold= me_threshold;
3583
        video_enc->intra_dc_precision= intra_dc_precision - 8;
3584

    
3585
        if (do_psnr)
3586
            video_enc->flags|= CODEC_FLAG_PSNR;
3587

    
3588
        /* two pass mode */
3589
        if (do_pass) {
3590
            if (do_pass == 1) {
3591
                video_enc->flags |= CODEC_FLAG_PASS1;
3592
            } else {
3593
                video_enc->flags |= CODEC_FLAG_PASS2;
3594
            }
3595
        }
3596

    
3597
        if (forced_key_frames)
3598
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3599
    }
3600
    if (video_language) {
3601
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3602
        av_freep(&video_language);
3603
    }
3604

    
3605
    /* reset some key parameters */
3606
    video_disable = 0;
3607
    av_freep(&video_codec_name);
3608
    av_freep(&forced_key_frames);
3609
    video_stream_copy = 0;
3610
    frame_pix_fmt = PIX_FMT_NONE;
3611
}
3612

    
3613
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3614
{
3615
    AVStream *st;
3616
    AVOutputStream *ost;
3617
    AVCodec *codec= NULL;
3618
    AVCodecContext *audio_enc;
3619
    enum CodecID codec_id = CODEC_ID_NONE;
3620

    
3621
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3622
    if (!st) {
3623
        fprintf(stderr, "Could not alloc stream\n");
3624
        ffmpeg_exit(1);
3625
    }
3626
    ost = new_output_stream(oc, file_idx);
3627

    
3628
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3629
    if(!audio_stream_copy){
3630
        if (audio_codec_name) {
3631
            codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3632
                                         avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3633
            codec = avcodec_find_encoder_by_name(audio_codec_name);
3634
            output_codecs[nb_output_codecs-1] = codec;
3635
        } else {
3636
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3637
            codec = avcodec_find_encoder(codec_id);
3638
        }
3639
    }
3640

    
3641
    avcodec_get_context_defaults3(st->codec, codec);
3642

    
3643
    ost->bitstream_filters = audio_bitstream_filters;
3644
    audio_bitstream_filters= NULL;
3645

    
3646
    st->codec->thread_count= thread_count;
3647

    
3648
    audio_enc = st->codec;
3649
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3650

    
3651
    if(audio_codec_tag)
3652
        audio_enc->codec_tag= audio_codec_tag;
3653

    
3654
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3655
        audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3656
        avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3657
    }
3658
    if (audio_stream_copy) {
3659
        st->stream_copy = 1;
3660
        audio_enc->channels = audio_channels;
3661
        audio_enc->sample_rate = audio_sample_rate;
3662
    } else {
3663
        audio_enc->codec_id = codec_id;
3664
        set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3665

    
3666
        if (audio_qscale > QSCALE_NONE) {
3667
            audio_enc->flags |= CODEC_FLAG_QSCALE;
3668
            audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3669
        }
3670
        audio_enc->channels = audio_channels;
3671
        audio_enc->sample_fmt = audio_sample_fmt;
3672
        audio_enc->sample_rate = audio_sample_rate;
3673
        audio_enc->channel_layout = channel_layout;
3674
        if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3675
            audio_enc->channel_layout = 0;
3676
        choose_sample_fmt(st, codec);
3677
        choose_sample_rate(st, codec);
3678
    }
3679
    audio_enc->time_base= (AVRational){1, audio_sample_rate};
3680
    if (audio_language) {
3681
        av_metadata_set2(&st->metadata, "language", audio_language, 0);
3682
        av_freep(&audio_language);
3683
    }
3684

    
3685
    /* reset some key parameters */
3686
    audio_disable = 0;
3687
    av_freep(&audio_codec_name);
3688
    audio_stream_copy = 0;
3689
}
3690

    
3691
static void new_data_stream(AVFormatContext *oc, int file_idx)
3692
{
3693
    AVStream *st;
3694
    AVOutputStream *ost;
3695
    AVCodec *codec=NULL;
3696
    AVCodecContext *data_enc;
3697

    
3698
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3699
    if (!st) {
3700
        fprintf(stderr, "Could not alloc stream\n");
3701
        ffmpeg_exit(1);
3702
    }
3703
    ost = new_output_stream(oc, file_idx);
3704
    data_enc = st->codec;
3705
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3706
    if (!data_stream_copy) {
3707
        fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3708
        ffmpeg_exit(1);
3709
    }
3710
    avcodec_get_context_defaults3(st->codec, codec);
3711

    
3712
    data_enc->codec_type = AVMEDIA_TYPE_DATA;
3713

    
3714
    if (data_codec_tag)
3715
        data_enc->codec_tag= data_codec_tag;
3716

    
3717
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3718
        data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3719
        avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3720
    }
3721
    if (data_stream_copy) {
3722
        st->stream_copy = 1;
3723
    }
3724

    
3725
    data_disable = 0;
3726
    av_freep(&data_codec_name);
3727
    data_stream_copy = 0;
3728
}
3729

    
3730
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3731
{
3732
    AVStream *st;
3733
    AVOutputStream *ost;
3734
    AVCodec *codec=NULL;
3735
    AVCodecContext *subtitle_enc;
3736
    enum CodecID codec_id = CODEC_ID_NONE;
3737

    
3738
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3739
    if (!st) {
3740
        fprintf(stderr, "Could not alloc stream\n");
3741
        ffmpeg_exit(1);
3742
    }
3743
    ost = new_output_stream(oc, file_idx);
3744
    subtitle_enc = st->codec;
3745
    output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3746
    if(!subtitle_stream_copy){
3747
        if (subtitle_codec_name) {
3748
            codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3749
                                         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3750
            codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3751
        } else {
3752
            codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3753
            codec = avcodec_find_encoder(codec_id);
3754
        }
3755
    }
3756
    avcodec_get_context_defaults3(st->codec, codec);
3757

    
3758
    ost->bitstream_filters = subtitle_bitstream_filters;
3759
    subtitle_bitstream_filters= NULL;
3760

    
3761
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3762

    
3763
    if(subtitle_codec_tag)
3764
        subtitle_enc->codec_tag= subtitle_codec_tag;
3765

    
3766
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3767
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3768
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3769
    }
3770
    if (subtitle_stream_copy) {
3771
        st->stream_copy = 1;
3772
    } else {
3773
        subtitle_enc->codec_id = codec_id;
3774
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3775
    }
3776

    
3777
    if (subtitle_language) {
3778
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3779
        av_freep(&subtitle_language);
3780
    }
3781

    
3782
    subtitle_disable = 0;
3783
    av_freep(&subtitle_codec_name);
3784
    subtitle_stream_copy = 0;
3785
}
3786

    
3787
static int opt_new_stream(const char *opt, const char *arg)
3788
{
3789
    AVFormatContext *oc;
3790
    int file_idx = nb_output_files - 1;
3791
    if (nb_output_files <= 0) {
3792
        fprintf(stderr, "At least one output file must be specified\n");
3793
        ffmpeg_exit(1);
3794
    }
3795
    oc = output_files[file_idx];
3796

    
3797
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3798
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3799
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3800
    else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3801
    else av_assert0(0);
3802
    return 0;
3803
}
3804

    
3805
/* arg format is "output-stream-index:streamid-value". */
3806
static int opt_streamid(const char *opt, const char *arg)
3807
{
3808
    int idx;
3809
    char *p;
3810
    char idx_str[16];
3811

    
3812
    av_strlcpy(idx_str, arg, sizeof(idx_str));
3813
    p = strchr(idx_str, ':');
3814
    if (!p) {
3815
        fprintf(stderr,
3816
                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3817
                arg, opt);
3818
        ffmpeg_exit(1);
3819
    }
3820
    *p++ = '\0';
3821
    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3822
    streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3823
    streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3824
    return 0;
3825
}
3826

    
3827
static void opt_output_file(const char *filename)
3828
{
3829
    AVFormatContext *oc;
3830
    int err, use_video, use_audio, use_subtitle, use_data;
3831
    int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3832
    AVFormatParameters params, *ap = &params;
3833
    AVOutputFormat *file_oformat;
3834

    
3835
    if (!strcmp(filename, "-"))
3836
        filename = "pipe:";
3837

    
3838
    oc = avformat_alloc_output_context(last_asked_format, NULL, filename);
3839
    last_asked_format = NULL;
3840
    if (!oc) {
3841
        print_error(filename, AVERROR(ENOMEM));
3842
        ffmpeg_exit(1);
3843
    }
3844
    file_oformat= oc->oformat;
3845

    
3846
    if (!strcmp(file_oformat->name, "ffm") &&
3847
        av_strstart(filename, "http:", NULL)) {
3848
        /* special case for files sent to ffserver: we get the stream
3849
           parameters from ffserver */
3850
        int err = read_ffserver_streams(oc, filename);
3851
        if (err < 0) {
3852
            print_error(filename, err);
3853
            ffmpeg_exit(1);
3854
        }
3855
    } else {
3856
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3857
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3858
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3859
        use_data = data_stream_copy ||  data_codec_name; /* XXX once generic data codec will be available add a ->data_codec reference and use it here */
3860

    
3861
        /* disable if no corresponding type found and at least one
3862
           input file */
3863
        if (nb_input_files > 0) {
3864
            check_inputs(&input_has_video,
3865
                         &input_has_audio,
3866
                         &input_has_subtitle,
3867
                         &input_has_data);
3868

    
3869
            if (!input_has_video)
3870
                use_video = 0;
3871
            if (!input_has_audio)
3872
                use_audio = 0;
3873
            if (!input_has_subtitle)
3874
                use_subtitle = 0;
3875
            if (!input_has_data)
3876
                use_data = 0;
3877
        }
3878

    
3879
        /* manual disable */
3880
        if (audio_disable)    use_audio    = 0;
3881
        if (video_disable)    use_video    = 0;
3882
        if (subtitle_disable) use_subtitle = 0;
3883
        if (data_disable)     use_data     = 0;
3884

    
3885
        if (use_video)    new_video_stream(oc, nb_output_files);
3886
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3887
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3888
        if (use_data)     new_data_stream(oc, nb_output_files);
3889

    
3890
        oc->timestamp = recording_timestamp;
3891

    
3892
        av_metadata_copy(&oc->metadata, metadata, 0);
3893
        av_metadata_free(&metadata);
3894
    }
3895

    
3896
    output_files[nb_output_files++] = oc;
3897

    
3898
    /* check filename in case of an image number is expected */
3899
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3900
        if (!av_filename_number_test(oc->filename)) {
3901
            print_error(oc->filename, AVERROR(EINVAL));
3902
            ffmpeg_exit(1);
3903
        }
3904
    }
3905

    
3906
    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3907
        /* test if it already exists to avoid loosing precious files */
3908
        if (!file_overwrite &&
3909
            (strchr(filename, ':') == NULL ||
3910
             filename[1] == ':' ||
3911
             av_strstart(filename, "file:", NULL))) {
3912
            if (avio_check(filename, 0) == 0) {
3913
                if (!using_stdin) {
3914
                    fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3915
                    fflush(stderr);
3916
                    if (!read_yesno()) {
3917
                        fprintf(stderr, "Not overwriting - exiting\n");
3918
                        ffmpeg_exit(1);
3919
                    }
3920
                }
3921
                else {
3922
                    fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3923
                    ffmpeg_exit(1);
3924
                }
3925
            }
3926
        }
3927

    
3928
        /* open the file */
3929
        if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3930
            print_error(filename, err);
3931
            ffmpeg_exit(1);
3932
        }
3933
    }
3934

    
3935
    memset(ap, 0, sizeof(*ap));
3936
    if (av_set_parameters(oc, ap) < 0) {
3937
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3938
                oc->filename);
3939
        ffmpeg_exit(1);
3940
    }
3941

    
3942
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3943
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3944
    oc->loop_output = loop_output;
3945

    
3946
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3947

    
3948
    av_freep(&forced_key_frames);
3949
}
3950

    
3951
/* same option as mencoder */
3952
static int opt_pass(const char *opt, const char *arg)
3953
{
3954
    do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3955
    return 0;
3956
}
3957

    
3958
static int64_t getutime(void)
3959
{
3960
#if HAVE_GETRUSAGE
3961
    struct rusage rusage;
3962

    
3963
    getrusage(RUSAGE_SELF, &rusage);
3964
    return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3965
#elif HAVE_GETPROCESSTIMES
3966
    HANDLE proc;
3967
    FILETIME c, e, k, u;
3968
    proc = GetCurrentProcess();
3969
    GetProcessTimes(proc, &c, &e, &k, &u);
3970
    return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3971
#else
3972
    return av_gettime();
3973
#endif
3974
}
3975

    
3976
static int64_t getmaxrss(void)
3977
{
3978
#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3979
    struct rusage rusage;
3980
    getrusage(RUSAGE_SELF, &rusage);
3981
    return (int64_t)rusage.ru_maxrss * 1024;
3982
#elif HAVE_GETPROCESSMEMORYINFO
3983
    HANDLE proc;
3984
    PROCESS_MEMORY_COUNTERS memcounters;
3985
    proc = GetCurrentProcess();
3986
    memcounters.cb = sizeof(memcounters);
3987
    GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3988
    return memcounters.PeakPagefileUsage;
3989
#else
3990
    return 0;
3991
#endif
3992
}
3993

    
3994
static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3995
{
3996
    int i;
3997
    const char *p = str;
3998
    for(i = 0;; i++) {
3999
        dest[i] = atoi(p);
4000
        if(i == 63)
4001
            break;
4002
        p = strchr(p, ',');
4003
        if(!p) {
4004
            fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4005
            ffmpeg_exit(1);
4006
        }
4007
        p++;
4008
    }
4009
}
4010

    
4011
static void opt_inter_matrix(const char *arg)
4012
{
4013
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4014
    parse_matrix_coeffs(inter_matrix, arg);
4015
}
4016

    
4017
static void opt_intra_matrix(const char *arg)
4018
{
4019
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4020
    parse_matrix_coeffs(intra_matrix, arg);
4021
}
4022

    
4023
static void show_usage(void)
4024
{
4025
    printf("Hyper fast Audio and Video encoder\n");
4026
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
4027
    printf("\n");
4028
}
4029

    
4030
static void show_help(void)
4031
{
4032
    AVCodec *c;
4033
    AVOutputFormat *oformat = NULL;
4034

    
4035
    av_log_set_callback(log_callback_help);
4036
    show_usage();
4037
    show_help_options(options, "Main options:\n",
4038
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4039
    show_help_options(options, "\nAdvanced options:\n",
4040
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4041
                      OPT_EXPERT);
4042
    show_help_options(options, "\nVideo options:\n",
4043
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4044
                      OPT_VIDEO);
4045
    show_help_options(options, "\nAdvanced Video options:\n",
4046
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4047
                      OPT_VIDEO | OPT_EXPERT);
4048
    show_help_options(options, "\nAudio options:\n",
4049
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4050
                      OPT_AUDIO);
4051
    show_help_options(options, "\nAdvanced Audio options:\n",
4052
                      OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4053
                      OPT_AUDIO | OPT_EXPERT);
4054
    show_help_options(options, "\nSubtitle options:\n",
4055
                      OPT_SUBTITLE | OPT_GRAB,
4056
                      OPT_SUBTITLE);
4057
    show_help_options(options, "\nAudio/Video grab options:\n",
4058
                      OPT_GRAB,
4059
                      OPT_GRAB);
4060
    printf("\n");
4061
    av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4062
    printf("\n");
4063

    
4064
    /* individual codec options */
4065
    c = NULL;
4066
    while ((c = av_codec_next(c))) {
4067
        if (c->priv_class) {
4068
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4069
            printf("\n");
4070
        }
4071
    }
4072

    
4073
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4074
    printf("\n");
4075

    
4076
    /* individual muxer options */
4077
    while ((oformat = av_oformat_next(oformat))) {
4078
        if (oformat->priv_class) {
4079
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4080
            printf("\n");
4081
        }
4082
    }
4083

    
4084
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4085
}
4086

    
4087
static void opt_target(const char *arg)
4088
{
4089
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4090
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4091

    
4092
    if(!strncmp(arg, "pal-", 4)) {
4093
        norm = PAL;
4094
        arg += 4;
4095
    } else if(!strncmp(arg, "ntsc-", 5)) {
4096
        norm = NTSC;
4097
        arg += 5;
4098
    } else if(!strncmp(arg, "film-", 5)) {
4099
        norm = FILM;
4100
        arg += 5;
4101
    } else {
4102
        int fr;
4103
        /* Calculate FR via float to avoid int overflow */
4104
        fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4105
        if(fr == 25000) {
4106
            norm = PAL;
4107
        } else if((fr == 29970) || (fr == 23976)) {
4108
            norm = NTSC;
4109
        } else {
4110
            /* Try to determine PAL/NTSC by peeking in the input files */
4111
            if(nb_input_files) {
4112
                int i, j;
4113
                for(j = 0; j < nb_input_files; j++) {
4114
                    for(i = 0; i < input_files[j]->nb_streams; i++) {
4115
                        AVCodecContext *c = input_files[j]->streams[i]->codec;
4116
                        if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4117
                            continue;
4118
                        fr = c->time_base.den * 1000 / c->time_base.num;
4119
                        if(fr == 25000) {
4120
                            norm = PAL;
4121
                            break;
4122
                        } else if((fr == 29970) || (fr == 23976)) {
4123
                            norm = NTSC;
4124
                            break;
4125
                        }
4126
                    }
4127
                    if(norm != UNKNOWN)
4128
                        break;
4129
                }
4130
            }
4131
        }
4132
        if(verbose > 0 && norm != UNKNOWN)
4133
            fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4134
    }
4135

    
4136
    if(norm == UNKNOWN) {
4137
        fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4138
        fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4139
        fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4140
        ffmpeg_exit(1);
4141
    }
4142

    
4143
    if(!strcmp(arg, "vcd")) {
4144

    
4145
        opt_video_codec("mpeg1video");
4146
        opt_audio_codec("mp2");
4147
        opt_format("vcd");
4148

    
4149
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4150
        opt_frame_rate(NULL, frame_rates[norm]);
4151
        opt_default("g", norm == PAL ? "15" : "18");
4152

    
4153
        opt_default("b", "1150000");
4154
        opt_default("maxrate", "1150000");
4155
        opt_default("minrate", "1150000");
4156
        opt_default("bufsize", "327680"); // 40*1024*8;
4157

    
4158
        opt_default("ab", "224000");
4159
        audio_sample_rate = 44100;
4160
        audio_channels = 2;
4161

    
4162
        opt_default("packetsize", "2324");
4163
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4164

    
4165
        /* We have to offset the PTS, so that it is consistent with the SCR.
4166
           SCR starts at 36000, but the first two packs contain only padding
4167
           and the first pack from the other stream, respectively, may also have
4168
           been written before.
4169
           So the real data starts at SCR 36000+3*1200. */
4170
        mux_preload= (36000+3*1200) / 90000.0; //0.44
4171
    } else if(!strcmp(arg, "svcd")) {
4172

    
4173
        opt_video_codec("mpeg2video");
4174
        opt_audio_codec("mp2");
4175
        opt_format("svcd");
4176

    
4177
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4178
        opt_frame_rate(NULL, frame_rates[norm]);
4179
        opt_default("g", norm == PAL ? "15" : "18");
4180

    
4181
        opt_default("b", "2040000");
4182
        opt_default("maxrate", "2516000");
4183
        opt_default("minrate", "0"); //1145000;
4184
        opt_default("bufsize", "1835008"); //224*1024*8;
4185
        opt_default("flags", "+scan_offset");
4186

    
4187

    
4188
        opt_default("ab", "224000");
4189
        audio_sample_rate = 44100;
4190

    
4191
        opt_default("packetsize", "2324");
4192

    
4193
    } else if(!strcmp(arg, "dvd")) {
4194

    
4195
        opt_video_codec("mpeg2video");
4196
        opt_audio_codec("ac3");
4197
        opt_format("dvd");
4198

    
4199
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4200
        opt_frame_rate(NULL, frame_rates[norm]);
4201
        opt_default("g", norm == PAL ? "15" : "18");
4202

    
4203
        opt_default("b", "6000000");
4204
        opt_default("maxrate", "9000000");
4205
        opt_default("minrate", "0"); //1500000;
4206
        opt_default("bufsize", "1835008"); //224*1024*8;
4207

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

    
4211
        opt_default("ab", "448000");
4212
        audio_sample_rate = 48000;
4213

    
4214
    } else if(!strncmp(arg, "dv", 2)) {
4215

    
4216
        opt_format("dv");
4217

    
4218
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4219
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4220
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4221
        opt_frame_rate(NULL, frame_rates[norm]);
4222

    
4223
        audio_sample_rate = 48000;
4224
        audio_channels = 2;
4225

    
4226
    } else {
4227
        fprintf(stderr, "Unknown target: %s\n", arg);
4228
        ffmpeg_exit(1);
4229
    }
4230
}
4231

    
4232
static void opt_vstats_file (const char *arg)
4233
{
4234
    av_free (vstats_filename);
4235
    vstats_filename=av_strdup (arg);
4236
}
4237

    
4238
static void opt_vstats (void)
4239
{
4240
    char filename[40];
4241
    time_t today2 = time(NULL);
4242
    struct tm *today = localtime(&today2);
4243

    
4244
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4245
             today->tm_sec);
4246
    opt_vstats_file(filename);
4247
}
4248

    
4249
static int opt_bsf(const char *opt, const char *arg)
4250
{
4251
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4252
    AVBitStreamFilterContext **bsfp;
4253

    
4254
    if(!bsfc){
4255
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4256
        ffmpeg_exit(1);
4257
    }
4258

    
4259
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4260
          *opt == 'a' ? &audio_bitstream_filters :
4261
                        &subtitle_bitstream_filters;
4262
    while(*bsfp)
4263
        bsfp= &(*bsfp)->next;
4264

    
4265
    *bsfp= bsfc;
4266

    
4267
    return 0;
4268
}
4269

    
4270
static int opt_preset(const char *opt, const char *arg)
4271
{
4272
    FILE *f=NULL;
4273
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4274
    char *codec_name = *opt == 'v' ? video_codec_name :
4275
                       *opt == 'a' ? audio_codec_name :
4276
                                     subtitle_codec_name;
4277

    
4278
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4279
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4280
        ffmpeg_exit(1);
4281
    }
4282

    
4283
    while(!feof(f)){
4284
        int e= fscanf(f, "%999[^\n]\n", line) - 1;
4285
        if(line[0] == '#' && !e)
4286
            continue;
4287
        e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4288
        if(e){
4289
            fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4290
            ffmpeg_exit(1);
4291
        }
4292
        if(!strcmp(tmp, "acodec")){
4293
            opt_audio_codec(tmp2);
4294
        }else if(!strcmp(tmp, "vcodec")){
4295
            opt_video_codec(tmp2);
4296
        }else if(!strcmp(tmp, "scodec")){
4297
            opt_subtitle_codec(tmp2);
4298
        }else if(!strcmp(tmp, "dcodec")){
4299
            opt_data_codec(tmp2);
4300
        }else if(opt_default(tmp, tmp2) < 0){
4301
            fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4302
            ffmpeg_exit(1);
4303
        }
4304
    }
4305

    
4306
    fclose(f);
4307

    
4308
    return 0;
4309
}
4310

    
4311
static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4312
{
4313
}
4314

    
4315
static void opt_passlogfile(const char *arg)
4316
{
4317
    pass_logfilename_prefix = arg;
4318
    opt_default("passlogfile", arg);
4319
}
4320

    
4321
static const OptionDef options[] = {
4322
    /* main options */
4323
#include "cmdutils_common_opts.h"
4324
    { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4325
    { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4326
    { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4327
    { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4328
    { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4329
      "outfile[,metadata]:infile[,metadata]" },
4330
    { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4331
      "outfile[,metadata]:infile[,metadata]" },
4332
    { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4333
    { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4334
    { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4335
    { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4336
    { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4337
    { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4338
    { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4339
    { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4340
    { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4341
    { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4342
      "add timings for benchmarking" },
4343
    { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4344
    { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4345
      "dump each input packet" },
4346
    { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4347
      "when dumping packets, also dump the payload" },
4348
    { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4349
    { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4350
    { "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)", "" },
4351
    { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4352
    { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4353
    { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4354
    { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4355
    { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4356
    { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4357
    { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4358
    { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4359
    { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4360
    { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4361
    { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4362
    { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4363
    { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4364
    { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4365

    
4366
    /* video options */
4367
    { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4368
    { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4369
    { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4370
    { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4371
    { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4372
    { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4373
    { "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" },
4374
    { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4375
    { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4376
    { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4377
    { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4378
    { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4379
    { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4380
    { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4381
    { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4382
    { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4383
    { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4384
    { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4385
    { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4386
    { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4387
    { "qscale", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4388
    { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4389
    { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4390
    { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4391
    { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4392
      "use same quantizer as source (implies VBR)" },
4393
    { "pass", HAS_ARG | OPT_FUNC2 | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4394
    { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4395
    { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4396
      "deinterlace pictures" },
4397
    { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4398
    { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4399
    { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4400
#if CONFIG_AVFILTER
4401
    { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4402
#endif
4403
    { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4404
    { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4405
    { "top", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4406
    { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4407
    { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4408
    { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4409
    { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4410
    { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4411
    { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4412
    { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4413
    { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4414

    
4415
    /* audio options */
4416
    { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4417
    { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4418
    { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4419
    { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4420
    { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4421
    { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4422
    { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4423
    { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4424
    { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4425
    { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4426
    { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4427
    { "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" },
4428

    
4429
    /* subtitle options */
4430
    { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4431
    { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4432
    { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4433
    { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4434
    { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4435

    
4436
    /* grab options */
4437
    { "vc", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4438
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4439
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4440

    
4441
    /* muxer options */
4442
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4443
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4444

    
4445
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4446
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4447
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4448

    
4449
    { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4450
    { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4451
    { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4452
    { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4453
    /* data codec support */
4454
    { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4455

    
4456
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4457
    { NULL, },
4458
};
4459

    
4460
int main(int argc, char **argv)
4461
{
4462
    int64_t ti;
4463

    
4464
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4465

    
4466
    if(argc>1 && !strcmp(argv[1], "-d")){
4467
        run_as_daemon=1;
4468
        verbose=-1;
4469
        av_log_set_callback(log_callback_null);
4470
        argc--;
4471
        argv++;
4472
    }
4473

    
4474
    avcodec_register_all();
4475
#if CONFIG_AVDEVICE
4476
    avdevice_register_all();
4477
#endif
4478
#if CONFIG_AVFILTER
4479
    avfilter_register_all();
4480
#endif
4481
    av_register_all();
4482

    
4483
#if HAVE_ISATTY
4484
    if(isatty(STDIN_FILENO))
4485
        avio_set_interrupt_cb(decode_interrupt_cb);
4486
#endif
4487

    
4488
    init_opts();
4489

    
4490
    show_banner();
4491

    
4492
    /* parse options */
4493
    parse_options(argc, argv, options, opt_output_file);
4494

    
4495
    if(nb_output_files <= 0 && nb_input_files == 0) {
4496
        show_usage();
4497
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4498
        ffmpeg_exit(1);
4499
    }
4500

    
4501
    /* file converter / grab */
4502
    if (nb_output_files <= 0) {
4503
        fprintf(stderr, "At least one output file must be specified\n");
4504
        ffmpeg_exit(1);
4505
    }
4506

    
4507
    if (nb_input_files == 0) {
4508
        fprintf(stderr, "At least one input file must be specified\n");
4509
        ffmpeg_exit(1);
4510
    }
4511

    
4512
    ti = getutime();
4513
    if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4514
                  stream_maps, nb_stream_maps) < 0)
4515
        ffmpeg_exit(1);
4516
    ti = getutime() - ti;
4517
    if (do_benchmark) {
4518
        int maxrss = getmaxrss() / 1024;
4519
        printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4520
    }
4521

    
4522
    return ffmpeg_exit(0);
4523
}