Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ eeaba924

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 resample_frame;              /* temporary frame for image 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

    
320
   int sws_flags;
321
} AVOutputStream;
322

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

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

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

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

    
354
#if HAVE_TERMIOS_H
355

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

    
360
#if CONFIG_AVFILTER
361

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

    
373
    ost->graph = avfilter_graph_alloc();
374

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

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

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

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

    
407
    snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
408
    ost->graph->scale_sws_opts = av_strdup(args);
409

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

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

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

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

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

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

    
442
    return 0;
443
}
444
#endif /* CONFIG_AVFILTER */
445

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

    
455
static volatile int received_sigterm = 0;
456

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

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

    
471
    tcgetattr (0, &tty);
472
    oldtty = tty;
473
    atexit(term_exit);
474

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

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

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

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

    
505
    if(run_as_daemon)
506
        return -1;
507

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

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

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

    
533
static int ffmpeg_exit(int ret)
534
{
535
    int i;
536

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

    
550
    av_free(intra_matrix);
551
    av_free(inter_matrix);
552

    
553
    if (vstats_file)
554
        fclose(vstats_file);
555
    av_free(vstats_filename);
556

    
557
    av_free(streamid_map);
558
    av_free(input_codecs);
559
    av_free(output_codecs);
560
    av_free(stream_maps);
561
    av_free(meta_data_maps);
562

    
563
    av_free(video_codec_name);
564
    av_free(audio_codec_name);
565
    av_free(subtitle_codec_name);
566
    av_free(data_codec_name);
567

    
568
    av_free(video_standard);
569

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

    
576
#if CONFIG_AVFILTER
577
    avfilter_uninit();
578
#endif
579

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

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

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

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

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

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

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

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

    
696
    ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
697
    return ost;
698
}
699

    
700
static int read_ffserver_streams(AVFormatContext *s, const char *filename)
701
{
702
    int i, err;
703
    AVFormatContext *ic;
704
    int nopts = 0;
705

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

    
715
        s->nb_streams++;
716

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

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

    
741
        if(st->codec->flags & CODEC_FLAG_BITEXACT)
742
            nopts = 1;
743

    
744
        new_output_stream(s, nb_output_files);
745
    }
746

    
747
    if (!nopts)
748
        s->timestamp = av_gettime();
749

    
750
    av_close_input_file(ic);
751
    return 0;
752
}
753

    
754
static double
755
get_sync_ipts(const AVOutputStream *ost)
756
{
757
    const AVInputStream *ist = ost->sync_ist;
758
    return (double)(ist->pts - start_time)/AV_TIME_BASE;
759
}
760

    
761
static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
762
    int ret;
763

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

    
783
        bsfc= bsfc->next;
784
    }
785

    
786
    ret= av_interleaved_write_frame(s, pkt);
787
    if(ret < 0){
788
        print_error("av_interleaved_write_frame()", ret);
789
        ffmpeg_exit(1);
790
    }
791
}
792

    
793
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
794

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

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

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

    
818
    audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
819
    if(coded_bps > 8*osize)
820
        audio_out_size= audio_out_size * coded_bps / (8*osize);
821
    audio_out_size += FF_MIN_BUFFER_SIZE;
822

    
823
    if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
824
        fprintf(stderr, "Buffer sizes too large\n");
825
        ffmpeg_exit(1);
826
    }
827

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

    
835
    if (enc->channels != dec->channels)
836
        ost->audio_resample = 1;
837

    
838
    resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
839
                       ost->resample_channels    != dec->channels   ||
840
                       ost->resample_sample_rate != dec->sample_rate;
841

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

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

    
893
    if(audio_sync_method){
894
        double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
895
                - av_fifo_size(ost->fifo)/(enc->channels * 2);
896
        double idelta= delta*dec->sample_rate / enc->sample_rate;
897
        int byte_delta= ((int)idelta)*2*dec->channels;
898

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

    
915
                    if(byte_delta > allocated_for_size - size){
916
                        allocated_for_size= byte_delta + (int64_t)size;
917
                        goto need_realloc;
918
                    }
919
                    ist->is_start=0;
920

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

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

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

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

    
977
        frame_bytes = enc->frame_size * osize * enc->channels;
978

    
979
        while (av_fifo_size(ost->fifo) >= frame_bytes) {
980
            AVPacket pkt;
981
            av_init_packet(&pkt);
982

    
983
            av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
984

    
985
            //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
986

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

    
1002
            ost->sync_opts += enc->frame_size;
1003
        }
1004
    } else {
1005
        AVPacket pkt;
1006
        av_init_packet(&pkt);
1007

    
1008
        ost->sync_opts += size_out / (osize * enc->channels);
1009

    
1010
        /* output a pcm frame */
1011
        /* determine the size of the coded buffer */
1012
        size_out /= osize;
1013
        if (coded_bps)
1014
            size_out = size_out*coded_bps/8;
1015

    
1016
        if(size_out > audio_out_size){
1017
            fprintf(stderr, "Internal error, buffer size too small\n");
1018
            ffmpeg_exit(1);
1019
        }
1020

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

    
1039
static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
1040
{
1041
    AVCodecContext *dec;
1042
    AVPicture *picture2;
1043
    AVPicture picture_tmp;
1044
    uint8_t *buf = 0;
1045

    
1046
    dec = ist->st->codec;
1047

    
1048
    /* deinterlace : must be done before any resize */
1049
    if (do_deinterlace) {
1050
        int size;
1051

    
1052
        /* create temporary picture */
1053
        size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1054
        buf = av_malloc(size);
1055
        if (!buf)
1056
            return;
1057

    
1058
        picture2 = &picture_tmp;
1059
        avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1060

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

    
1073
    if (picture != picture2)
1074
        *picture = *picture2;
1075
    *bufp = buf;
1076
}
1077

    
1078
/* we begin to correct av delay at this threshold */
1079
#define AV_DELAY_MAX 0.100
1080

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

    
1093
    if (pts == AV_NOPTS_VALUE) {
1094
        fprintf(stderr, "Subtitle packets must have a pts\n");
1095
        if (exit_on_error)
1096
            ffmpeg_exit(1);
1097
        return;
1098
    }
1099

    
1100
    enc = ost->st->codec;
1101

    
1102
    if (!subtitle_out) {
1103
        subtitle_out = av_malloc(subtitle_out_max_size);
1104
    }
1105

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

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

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

    
1144
static int bit_buffer_size= 1024*256;
1145
static uint8_t *bit_buffer= NULL;
1146

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

    
1158
    enc = ost->st->codec;
1159
    dec = ist->st->codec;
1160

    
1161
    sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1162

    
1163
    /* by default, we output a single frame */
1164
    nb_frames = 1;
1165

    
1166
    *frame_size = 0;
1167

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

    
1193
    nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1194
    if (nb_frames <= 0)
1195
        return;
1196

    
1197
    formatted_picture = in_picture;
1198
    final_picture = formatted_picture;
1199

    
1200
#if !CONFIG_AVFILTER
1201
    resample_changed = ost->resample_width   != dec->width  ||
1202
                       ost->resample_height  != dec->height ||
1203
                       ost->resample_pix_fmt != dec->pix_fmt;
1204

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

    
1216
    ost->video_resample = dec->width   != enc->width  ||
1217
                          dec->height  != enc->height ||
1218
                          dec->pix_fmt != enc->pix_fmt;
1219

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

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

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

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

    
1269
            big_picture= *final_picture;
1270
            /* better than nothing: use input picture interlaced
1271
               settings */
1272
            big_picture.interlaced_frame = in_picture->interlaced_frame;
1273
            if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1274
                if(top_field_first == -1)
1275
                    big_picture.top_field_first = in_picture->top_field_first;
1276
                else
1277
                    big_picture.top_field_first = top_field_first;
1278
            }
1279

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

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

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

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

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

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

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

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

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

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

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

    
1397

    
1398
    oc = output_files[0];
1399

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

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

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

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

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

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

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

    
1477
        fflush(stderr);
1478
    }
1479

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

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

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

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

    
1521
    if(ist->next_pts == AV_NOPTS_VALUE)
1522
        ist->next_pts= ist->pts;
1523

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

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

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

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

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

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

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

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

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

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

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

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

    
1733
                        av_init_packet(&opkt);
1734

    
1735
                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1736
#if !CONFIG_AVFILTER
1737
                            continue;
1738
#else
1739
                            goto cont;
1740
#endif
1741

    
1742
                        /* no reencoding needed : output the packet directly */
1743
                        /* force the input stream PTS */
1744

    
1745
                        avcodec_get_frame_defaults(&avframe);
1746
                        ost->st->codec->coded_frame= &avframe;
1747
                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1748

    
1749
                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1750
                            audio_size += data_size;
1751
                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1752
                            video_size += data_size;
1753
                            ost->sync_opts++;
1754
                        }
1755

    
1756
                        opkt.stream_index= ost->index;
1757
                        if(pkt->pts != AV_NOPTS_VALUE)
1758
                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1759
                        else
1760
                            opkt.pts= AV_NOPTS_VALUE;
1761

    
1762
                        if (pkt->dts == AV_NOPTS_VALUE)
1763
                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1764
                        else
1765
                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1766
                        opkt.dts -= ost_tb_start_time;
1767

    
1768
                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1769
                        opkt.flags= pkt->flags;
1770

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

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

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

    
1810
        for(i=0;i<nb_ostreams;i++) {
1811
            ost = ost_table[i];
1812
            if (ost->source_index == ist_index) {
1813
                AVCodecContext *enc= ost->st->codec;
1814
                os = output_files[ost->file_index];
1815

    
1816
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1817
                    continue;
1818
                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1819
                    continue;
1820

    
1821
                if (ost->encoding_needed) {
1822
                    for(;;) {
1823
                        AVPacket pkt;
1824
                        int fifo_bytes;
1825
                        av_init_packet(&pkt);
1826
                        pkt.stream_index= ost->index;
1827

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

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

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

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

    
1892
    return 0;
1893
 fail_decode:
1894
    return -1;
1895
}
1896

    
1897
static void print_sdp(AVFormatContext **avc, int n)
1898
{
1899
    char sdp[2048];
1900

    
1901
    av_sdp_create(avc, n, sdp, sizeof(sdp));
1902
    printf("SDP:\n%s\n", sdp);
1903
    fflush(stdout);
1904
}
1905

    
1906
static int copy_chapters(int infile, int outfile)
1907
{
1908
    AVFormatContext *is = input_files[infile];
1909
    AVFormatContext *os = output_files[outfile];
1910
    int i;
1911

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

    
1919

    
1920
        if (in_ch->end < ts_off)
1921
            continue;
1922
        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1923
            break;
1924

    
1925
        out_ch = av_mallocz(sizeof(AVChapter));
1926
        if (!out_ch)
1927
            return AVERROR(ENOMEM);
1928

    
1929
        out_ch->id        = in_ch->id;
1930
        out_ch->time_base = in_ch->time_base;
1931
        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1932
        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1933

    
1934
        if (metadata_chapters_autocopy)
1935
            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1936

    
1937
        os->nb_chapters++;
1938
        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1939
        if (!os->chapters)
1940
            return AVERROR(ENOMEM);
1941
        os->chapters[os->nb_chapters - 1] = out_ch;
1942
    }
1943
    return 0;
1944
}
1945

    
1946
static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1947
                                    AVCodecContext *avctx)
1948
{
1949
    char *p;
1950
    int n = 1, i;
1951
    int64_t t;
1952

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

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

    
1992
    file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1993
    if (!file_table)
1994
        goto fail;
1995

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

    
2006
    ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
2007
    if (!ist_table)
2008
        goto fail;
2009

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

    
2027
            if (rate_emu) {
2028
                ist->start = av_gettime();
2029
            }
2030
        }
2031
    }
2032

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

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

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

    
2072
    ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
2073
    if (!ost_table)
2074
        goto fail;
2075

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

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

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

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

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

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

    
2196
        codec = ost->st->codec;
2197
        icodec = ist->st->codec;
2198

    
2199
        if (metadata_streams_autocopy)
2200
            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2201
                             AV_METADATA_DONT_OVERWRITE);
2202

    
2203
        ost->st->disposition = ist->st->disposition;
2204
        codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2205
        codec->chroma_sample_location = icodec->chroma_sample_location;
2206

    
2207
        if (ost->st->stream_copy) {
2208
            uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2209

    
2210
            if (extra_size > INT_MAX)
2211
                goto fail;
2212

    
2213
            /* if stream_copy is selected, no need to decode or encode */
2214
            codec->codec_id = icodec->codec_id;
2215
            codec->codec_type = icodec->codec_type;
2216

    
2217
            if(!codec->codec_tag){
2218
                if(   !os->oformat->codec_tag
2219
                   || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2220
                   || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2221
                    codec->codec_tag = icodec->codec_tag;
2222
            }
2223

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

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

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

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

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

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

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

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

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

    
2449
        int out_file_index = meta_data_maps[i][0].file;
2450
        int in_file_index = meta_data_maps[i][1].file;
2451
        if (in_file_index < 0 || out_file_index < 0)
2452
            continue;
2453
        METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2454
        METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2455

    
2456
        files[0] = output_files[out_file_index];
2457
        files[1] = input_files[in_file_index];
2458

    
2459
        for (j = 0; j < 2; j++) {
2460
            AVMetaDataMap *map = &meta_data_maps[i][j];
2461

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

    
2481
        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2482
    }
2483

    
2484
    /* copy global metadata by default */
2485
    if (metadata_global_autocopy) {
2486

    
2487
        for (i = 0; i < nb_output_files; i++)
2488
            av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2489
                             AV_METADATA_DONT_OVERWRITE);
2490
    }
2491

    
2492
    /* copy chapters according to chapter maps */
2493
    for (i = 0; i < nb_chapter_maps; i++) {
2494
        int infile  = chapter_maps[i].in_file;
2495
        int outfile = chapter_maps[i].out_file;
2496

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

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

    
2518
            for (j = 0; j < nb_output_files; j++)
2519
                if ((ret = copy_chapters(i, j)) < 0)
2520
                    goto dump_format;
2521
            break;
2522
        }
2523

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

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

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

    
2562
    if (ret) {
2563
        fprintf(stderr, "%s\n", error);
2564
        goto fail;
2565
    }
2566

    
2567
    if (want_sdp) {
2568
        print_sdp(output_files, nb_output_files);
2569
    }
2570

    
2571
    if (!using_stdin) {
2572
        if(verbose >= 0)
2573
            fprintf(stderr, "Press [q] to stop encoding\n");
2574
        avio_set_interrupt_cb(decode_interrupt_cb);
2575
    }
2576
    term_init();
2577

    
2578
    timer_start = av_gettime();
2579

    
2580
    for(; received_sigterm == 0;) {
2581
        int file_index, ist_index;
2582
        AVPacket pkt;
2583
        double ipts_min;
2584
        double opts_min;
2585

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

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

    
2637
        /* finish if limit size exhausted */
2638
        if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2639
            break;
2640

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

    
2657
        no_packet_count=0;
2658
        memset(no_packet, 0, sizeof(no_packet));
2659

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

    
2673
        if (pkt.dts != AV_NOPTS_VALUE)
2674
            pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2675
        if (pkt.pts != AV_NOPTS_VALUE)
2676
            pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2677

    
2678
        if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2679
            && input_files_ts_scale[file_index][pkt.stream_index]){
2680
            if(pkt.pts != AV_NOPTS_VALUE)
2681
                pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2682
            if(pkt.dts != AV_NOPTS_VALUE)
2683
                pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2684
        }
2685

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

    
2701
        /* finish if recording time exhausted */
2702
        if (recording_time != INT64_MAX &&
2703
            (pkt.pts != AV_NOPTS_VALUE || pkt.dts != AV_NOPTS_VALUE ?
2704
                av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000})
2705
                    :
2706
                av_compare_ts(ist->pts, AV_TIME_BASE_Q, recording_time + start_time, (AVRational){1, 1000000})
2707
            )>= 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->resample_frame.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
    uninit_opts();
3417
    init_opts();
3418
}
3419

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

    
3428
    has_video = 0;
3429
    has_audio = 0;
3430
    has_subtitle = 0;
3431
    has_data = 0;
3432

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

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

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

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

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

    
3501
    st->codec->thread_count= thread_count;
3502

    
3503
    video_enc = st->codec;
3504

    
3505
    if(video_codec_tag)
3506
        video_enc->codec_tag= video_codec_tag;
3507

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

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

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

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

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

    
3542
        choose_pixel_fmt(st, codec);
3543

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

    
3552
        if(intra_matrix)
3553
            video_enc->intra_matrix = intra_matrix;
3554
        if(inter_matrix)
3555
            video_enc->inter_matrix = inter_matrix;
3556

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

    
3587
        if (do_psnr)
3588
            video_enc->flags|= CODEC_FLAG_PSNR;
3589

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

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

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

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

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

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

    
3643
    avcodec_get_context_defaults3(st->codec, codec);
3644

    
3645
    ost->bitstream_filters = audio_bitstream_filters;
3646
    audio_bitstream_filters= NULL;
3647

    
3648
    st->codec->thread_count= thread_count;
3649

    
3650
    audio_enc = st->codec;
3651
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3652

    
3653
    if(audio_codec_tag)
3654
        audio_enc->codec_tag= audio_codec_tag;
3655

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

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

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

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

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

    
3714
    data_enc->codec_type = AVMEDIA_TYPE_DATA;
3715

    
3716
    if (data_codec_tag)
3717
        data_enc->codec_tag= data_codec_tag;
3718

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

    
3727
    data_disable = 0;
3728
    av_freep(&data_codec_name);
3729
    data_stream_copy = 0;
3730
}
3731

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

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

    
3760
    ost->bitstream_filters = subtitle_bitstream_filters;
3761
    subtitle_bitstream_filters= NULL;
3762

    
3763
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3764

    
3765
    if(subtitle_codec_tag)
3766
        subtitle_enc->codec_tag= subtitle_codec_tag;
3767

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

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

    
3784
    subtitle_disable = 0;
3785
    av_freep(&subtitle_codec_name);
3786
    subtitle_stream_copy = 0;
3787
}
3788

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

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

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

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

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

    
3837
    if (!strcmp(filename, "-"))
3838
        filename = "pipe:";
3839

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

    
3848
    if (!strcmp(file_oformat->name, "ffm") &&
3849
        av_strstart(filename, "http:", NULL)) {
3850
        /* special case for files sent to ffserver: we get the stream
3851
           parameters from ffserver */
3852
        int err = read_ffserver_streams(oc, filename);
3853
        if (err < 0) {
3854
            print_error(filename, err);
3855
            ffmpeg_exit(1);
3856
        }
3857
    } else {
3858
        use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3859
        use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3860
        use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3861
        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 */
3862

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

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

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

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

    
3892
        oc->timestamp = recording_timestamp;
3893

    
3894
        av_metadata_copy(&oc->metadata, metadata, 0);
3895
        av_metadata_free(&metadata);
3896
    }
3897

    
3898
    output_files[nb_output_files++] = oc;
3899

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

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

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

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

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

    
3948
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3949

    
3950
    av_freep(&forced_key_frames);
3951
    uninit_opts();
3952
    init_opts();
3953
}
3954

    
3955
/* same option as mencoder */
3956
static int opt_pass(const char *opt, const char *arg)
3957
{
3958
    do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3959
    return 0;
3960
}
3961

    
3962
static int64_t getutime(void)
3963
{
3964
#if HAVE_GETRUSAGE
3965
    struct rusage rusage;
3966

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

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

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

    
4015
static void opt_inter_matrix(const char *arg)
4016
{
4017
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4018
    parse_matrix_coeffs(inter_matrix, arg);
4019
}
4020

    
4021
static void opt_intra_matrix(const char *arg)
4022
{
4023
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4024
    parse_matrix_coeffs(intra_matrix, arg);
4025
}
4026

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

    
4034
static void show_help(void)
4035
{
4036
    AVCodec *c;
4037
    AVOutputFormat *oformat = NULL;
4038

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

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

    
4077
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4078
    printf("\n");
4079

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

    
4088
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4089
}
4090

    
4091
static void opt_target(const char *arg)
4092
{
4093
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4094
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4095

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

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

    
4147
    if(!strcmp(arg, "vcd")) {
4148

    
4149
        opt_video_codec("mpeg1video");
4150
        opt_audio_codec("mp2");
4151
        opt_format("vcd");
4152

    
4153
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4154
        opt_frame_rate(NULL, frame_rates[norm]);
4155
        opt_default("g", norm == PAL ? "15" : "18");
4156

    
4157
        opt_default("b", "1150000");
4158
        opt_default("maxrate", "1150000");
4159
        opt_default("minrate", "1150000");
4160
        opt_default("bufsize", "327680"); // 40*1024*8;
4161

    
4162
        opt_default("ab", "224000");
4163
        audio_sample_rate = 44100;
4164
        audio_channels = 2;
4165

    
4166
        opt_default("packetsize", "2324");
4167
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4168

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

    
4177
        opt_video_codec("mpeg2video");
4178
        opt_audio_codec("mp2");
4179
        opt_format("svcd");
4180

    
4181
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4182
        opt_frame_rate(NULL, frame_rates[norm]);
4183
        opt_default("g", norm == PAL ? "15" : "18");
4184

    
4185
        opt_default("b", "2040000");
4186
        opt_default("maxrate", "2516000");
4187
        opt_default("minrate", "0"); //1145000;
4188
        opt_default("bufsize", "1835008"); //224*1024*8;
4189
        opt_default("flags", "+scan_offset");
4190

    
4191

    
4192
        opt_default("ab", "224000");
4193
        audio_sample_rate = 44100;
4194

    
4195
        opt_default("packetsize", "2324");
4196

    
4197
    } else if(!strcmp(arg, "dvd")) {
4198

    
4199
        opt_video_codec("mpeg2video");
4200
        opt_audio_codec("ac3");
4201
        opt_format("dvd");
4202

    
4203
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4204
        opt_frame_rate(NULL, frame_rates[norm]);
4205
        opt_default("g", norm == PAL ? "15" : "18");
4206

    
4207
        opt_default("b", "6000000");
4208
        opt_default("maxrate", "9000000");
4209
        opt_default("minrate", "0"); //1500000;
4210
        opt_default("bufsize", "1835008"); //224*1024*8;
4211

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

    
4215
        opt_default("ab", "448000");
4216
        audio_sample_rate = 48000;
4217

    
4218
    } else if(!strncmp(arg, "dv", 2)) {
4219

    
4220
        opt_format("dv");
4221

    
4222
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4223
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4224
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4225
        opt_frame_rate(NULL, frame_rates[norm]);
4226

    
4227
        audio_sample_rate = 48000;
4228
        audio_channels = 2;
4229

    
4230
    } else {
4231
        fprintf(stderr, "Unknown target: %s\n", arg);
4232
        ffmpeg_exit(1);
4233
    }
4234
}
4235

    
4236
static void opt_vstats_file (const char *arg)
4237
{
4238
    av_free (vstats_filename);
4239
    vstats_filename=av_strdup (arg);
4240
}
4241

    
4242
static void opt_vstats (void)
4243
{
4244
    char filename[40];
4245
    time_t today2 = time(NULL);
4246
    struct tm *today = localtime(&today2);
4247

    
4248
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4249
             today->tm_sec);
4250
    opt_vstats_file(filename);
4251
}
4252

    
4253
static int opt_bsf(const char *opt, const char *arg)
4254
{
4255
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4256
    AVBitStreamFilterContext **bsfp;
4257

    
4258
    if(!bsfc){
4259
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4260
        ffmpeg_exit(1);
4261
    }
4262

    
4263
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4264
          *opt == 'a' ? &audio_bitstream_filters :
4265
                        &subtitle_bitstream_filters;
4266
    while(*bsfp)
4267
        bsfp= &(*bsfp)->next;
4268

    
4269
    *bsfp= bsfc;
4270

    
4271
    return 0;
4272
}
4273

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

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

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

    
4310
    fclose(f);
4311

    
4312
    return 0;
4313
}
4314

    
4315
static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4316
{
4317
}
4318

    
4319
static void opt_passlogfile(const char *arg)
4320
{
4321
    pass_logfilename_prefix = arg;
4322
    opt_default("passlogfile", arg);
4323
}
4324

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

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

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

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

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

    
4445
    /* muxer options */
4446
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4447
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4448

    
4449
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4450
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4451
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4452

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

    
4460
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4461
    { NULL, },
4462
};
4463

    
4464
int main(int argc, char **argv)
4465
{
4466
    int64_t ti;
4467

    
4468
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4469

    
4470
    if(argc>1 && !strcmp(argv[1], "-d")){
4471
        run_as_daemon=1;
4472
        verbose=-1;
4473
        av_log_set_callback(log_callback_null);
4474
        argc--;
4475
        argv++;
4476
    }
4477

    
4478
    avcodec_register_all();
4479
#if CONFIG_AVDEVICE
4480
    avdevice_register_all();
4481
#endif
4482
#if CONFIG_AVFILTER
4483
    avfilter_register_all();
4484
#endif
4485
    av_register_all();
4486

    
4487
#if HAVE_ISATTY
4488
    if(isatty(STDIN_FILENO))
4489
        avio_set_interrupt_cb(decode_interrupt_cb);
4490
#endif
4491

    
4492
    init_opts();
4493

    
4494
    show_banner();
4495

    
4496
    /* parse options */
4497
    parse_options(argc, argv, options, opt_output_file);
4498

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

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

    
4511
    if (nb_input_files == 0) {
4512
        fprintf(stderr, "At least one input file must be specified\n");
4513
        ffmpeg_exit(1);
4514
    }
4515

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

    
4526
    return ffmpeg_exit(0);
4527
}