Statistics
| Branch: | Revision:

ffmpeg / ffmpeg.c @ 04c373c1

History | View | Annotate | Download (165 KB)

1
/*
2
 * ffmpeg main
3
 * Copyright (c) 2000-2003 Fabrice Bellard
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/* needed for usleep() */
23
#define _XOPEN_SOURCE 600
24

    
25
#include "config.h"
26
#include <ctype.h>
27
#include <string.h>
28
#include <math.h>
29
#include <stdlib.h>
30
#include <errno.h>
31
#include <signal.h>
32
#include <limits.h>
33
#include <unistd.h>
34
#include "libavformat/avformat.h"
35
#include "libavdevice/avdevice.h"
36
#include "libswscale/swscale.h"
37
#include "libavutil/opt.h"
38
#include "libavcodec/audioconvert.h"
39
#include "libavutil/audioconvert.h"
40
#include "libavutil/parseutils.h"
41
#include "libavutil/samplefmt.h"
42
#include "libavutil/colorspace.h"
43
#include "libavutil/fifo.h"
44
#include "libavutil/intreadwrite.h"
45
#include "libavutil/pixdesc.h"
46
#include "libavutil/avstring.h"
47
#include "libavutil/libm.h"
48
#include "libavformat/os_support.h"
49

    
50
#include "libavformat/ffm.h" // not public API
51

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

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

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

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

    
85
#include "cmdutils.h"
86

    
87
#include "libavutil/avassert.h"
88

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

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

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

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

    
114
static const OptionDef options[];
115

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

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

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

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

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

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

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

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

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

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

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

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

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

    
232
static int rate_emu = 0;
233

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

    
237
static int audio_volume = 256;
238

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

    
255
static float dts_delta_threshold = 10;
256

    
257
static int64_t timer_start;
258

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

    
263
static short *samples;
264

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

    
269
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
270

    
271
struct AVInputStream;
272

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

    
294
    float frame_aspect_ratio;
295

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

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

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

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

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

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

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

    
352
#if HAVE_TERMIOS_H
353

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

    
358
#if CONFIG_AVFILTER
359

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

    
371
    ost->graph = avfilter_graph_alloc();
372

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

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

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

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

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

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

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

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

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

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

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

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

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

    
453
static volatile int received_sigterm = 0;
454

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

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

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

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

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

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

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

    
503
    if(run_as_daemon)
504
        return -1;
505

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

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

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

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

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

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

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

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

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

    
566
    av_free(video_standard);
567

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

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

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

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

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

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

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

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

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

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

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

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

    
711
        s->nb_streams++;
712

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

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

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

    
740
        new_output_stream(s, nb_output_files);
741
    }
742

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

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

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

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

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

    
779
        bsfc= bsfc->next;
780
    }
781

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

    
789
#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
790

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1162
    *frame_size = 0;
1163

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

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

    
1193
    formatted_picture = in_picture;
1194
    final_picture = formatted_picture;
1195

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

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

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

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

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

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

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

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

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

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

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

    
1326
static double psnr(double d){
1327
    return -10.0*log(d)/log(10.0);
1328
}
1329

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

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

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

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

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

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

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

    
1394

    
1395
    oc = output_files[0];
1396

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

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

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

    
1460
    if (verbose > 0 || is_last_report) {
1461
        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1462

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

    
1467
        if (nb_frames_dup || nb_frames_drop)
1468
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1469
                  nb_frames_dup, nb_frames_drop);
1470

    
1471
        if (verbose >= 0)
1472
            fprintf(stderr, "%s    \r", buf);
1473

    
1474
        fflush(stderr);
1475
    }
1476

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

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

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

    
1515
    AVPacket avpkt;
1516
    int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1517

    
1518
    if(ist->next_pts == AV_NOPTS_VALUE)
1519
        ist->next_pts= ist->pts;
1520

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

    
1531
    if(pkt->dts != AV_NOPTS_VALUE)
1532
        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1533
    if(pkt->pts != AV_NOPTS_VALUE)
1534
        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1535

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

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

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

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

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

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

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

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

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

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

    
1732
                        av_init_packet(&opkt);
1733

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1918

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
2577
    timer_start = av_gettime();
2578

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

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

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

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

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

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

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

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

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

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

    
2700
        /* finish if recording time exhausted */
2701
        if (recording_time != INT64_MAX &&
2702
            av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2703
            ist->is_past_recording_time = 1;
2704
            goto discard_packet;
2705
        }
2706

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

    
2710
            if (verbose >= 0)
2711
                fprintf(stderr, "Error while decoding stream #%d.%d\n",
2712
                        ist->file_index, ist->index);
2713
            if (exit_on_error)
2714
                ffmpeg_exit(1);
2715
            av_free_packet(&pkt);
2716
            goto redo;
2717
        }
2718

    
2719
    discard_packet:
2720
        av_free_packet(&pkt);
2721

    
2722
        /* dump report by using the output first video and audio streams */
2723
        print_report(output_files, ost_table, nb_ostreams, 0);
2724
    }
2725

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

    
2734
    term_exit();
2735

    
2736
    /* write the trailer if needed and close file */
2737
    for(i=0;i<nb_output_files;i++) {
2738
        os = output_files[i];
2739
        av_write_trailer(os);
2740
    }
2741

    
2742
    /* dump report by using the first video and audio streams */
2743
    print_report(output_files, ost_table, nb_ostreams, 1);
2744

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

    
2757
    /* close each decoder */
2758
    for(i=0;i<nb_istreams;i++) {
2759
        ist = ist_table[i];
2760
        if (ist->decoding_needed) {
2761
            avcodec_close(ist->st->codec);
2762
        }
2763
    }
2764

    
2765
    /* finished ! */
2766
    ret = 0;
2767

    
2768
 fail:
2769
    av_freep(&bit_buffer);
2770
    av_free(file_table);
2771

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

    
2808
static void opt_format(const char *arg)
2809
{
2810
    last_asked_format = arg;
2811
}
2812

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

    
2818
static int opt_me_threshold(const char *opt, const char *arg)
2819
{
2820
    me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2821
    return 0;
2822
}
2823

    
2824
static int opt_verbose(const char *opt, const char *arg)
2825
{
2826
    verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2827
    return 0;
2828
}
2829

    
2830
static int opt_frame_rate(const char *opt, const char *arg)
2831
{
2832
    if (av_parse_video_rate(&frame_rate, arg) < 0) {
2833
        fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2834
        ffmpeg_exit(1);
2835
    }
2836
    return 0;
2837
}
2838

    
2839
static int opt_bitrate(const char *opt, const char *arg)
2840
{
2841
    int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2842

    
2843
    opt_default(opt, arg);
2844

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

    
2848
    return 0;
2849
}
2850

    
2851
static int opt_frame_crop(const char *opt, const char *arg)
2852
{
2853
    fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2854
    return AVERROR(EINVAL);
2855
}
2856

    
2857
static void opt_frame_size(const char *arg)
2858
{
2859
    if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2860
        fprintf(stderr, "Incorrect frame size\n");
2861
        ffmpeg_exit(1);
2862
    }
2863
}
2864

    
2865
static int opt_pad(const char *opt, const char *arg) {
2866
    fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2867
    return -1;
2868
}
2869

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

    
2884
static void opt_frame_aspect_ratio(const char *arg)
2885
{
2886
    int x = 0, y = 0;
2887
    double ar = 0;
2888
    const char *p;
2889
    char *end;
2890

    
2891
    p = strchr(arg, ':');
2892
    if (p) {
2893
        x = strtol(arg, &end, 10);
2894
        if (end == p)
2895
            y = strtol(end+1, &end, 10);
2896
        if (x > 0 && y > 0)
2897
            ar = (double)x / (double)y;
2898
    } else
2899
        ar = strtod(arg, NULL);
2900

    
2901
    if (!ar) {
2902
        fprintf(stderr, "Incorrect aspect ratio specification.\n");
2903
        ffmpeg_exit(1);
2904
    }
2905
    frame_aspect_ratio = ar;
2906
}
2907

    
2908
static int opt_metadata(const char *opt, const char *arg)
2909
{
2910
    char *mid= strchr(arg, '=');
2911

    
2912
    if(!mid){
2913
        fprintf(stderr, "Missing =\n");
2914
        ffmpeg_exit(1);
2915
    }
2916
    *mid++= 0;
2917

    
2918
    av_metadata_set2(&metadata, arg, mid, 0);
2919

    
2920
    return 0;
2921
}
2922

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

    
2933
static int opt_top_field_first(const char *opt, const char *arg)
2934
{
2935
    top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2936
    return 0;
2937
}
2938

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

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

    
2966
static int opt_audio_rate(const char *opt, const char *arg)
2967
{
2968
    audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2969
    return 0;
2970
}
2971

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

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

    
2984
static void opt_video_standard(const char *arg)
2985
{
2986
    video_standard = av_strdup(arg);
2987
}
2988

    
2989
static void opt_codec(int *pstream_copy, char **pcodec_name,
2990
                      int codec_type, const char *arg)
2991
{
2992
    av_freep(pcodec_name);
2993
    if (!strcmp(arg, "copy")) {
2994
        *pstream_copy = 1;
2995
    } else {
2996
        *pcodec_name = av_strdup(arg);
2997
    }
2998
}
2999

    
3000
static void opt_audio_codec(const char *arg)
3001
{
3002
    opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
3003
}
3004

    
3005
static void opt_video_codec(const char *arg)
3006
{
3007
    opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
3008
}
3009

    
3010
static void opt_subtitle_codec(const char *arg)
3011
{
3012
    opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
3013
}
3014

    
3015
static void opt_data_codec(const char *arg)
3016
{
3017
    opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
3018
}
3019

    
3020
static int opt_codec_tag(const char *opt, const char *arg)
3021
{
3022
    char *tail;
3023
    uint32_t *codec_tag;
3024

    
3025
    codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
3026
                !strcmp(opt, "vtag") ? &video_codec_tag :
3027
                !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
3028
    if (!codec_tag)
3029
        return -1;
3030

    
3031
    *codec_tag = strtol(arg, &tail, 0);
3032
    if (!tail || *tail)
3033
        *codec_tag = AV_RL32(arg);
3034

    
3035
    return 0;
3036
}
3037

    
3038
static void opt_map(const char *arg)
3039
{
3040
    AVStreamMap *m;
3041
    char *p;
3042

    
3043
    stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
3044
    m = &stream_maps[nb_stream_maps-1];
3045

    
3046
    m->file_index = strtol(arg, &p, 0);
3047
    if (*p)
3048
        p++;
3049

    
3050
    m->stream_index = strtol(p, &p, 0);
3051
    if (*p) {
3052
        p++;
3053
        m->sync_file_index = strtol(p, &p, 0);
3054
        if (*p)
3055
            p++;
3056
        m->sync_stream_index = strtol(p, &p, 0);
3057
    } else {
3058
        m->sync_file_index = m->file_index;
3059
        m->sync_stream_index = m->stream_index;
3060
    }
3061
}
3062

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

    
3084
static void opt_map_metadata(const char *arg)
3085
{
3086
    AVMetaDataMap *m, *m1;
3087
    char *p;
3088

    
3089
    meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
3090
                                &nb_meta_data_maps, nb_meta_data_maps + 1);
3091

    
3092
    m = &meta_data_maps[nb_meta_data_maps - 1][0];
3093
    m->file = strtol(arg, &p, 0);
3094
    parse_meta_type(p, &m->type, &m->index, &p);
3095
    if (*p)
3096
        p++;
3097

    
3098
    m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3099
    m1->file = strtol(p, &p, 0);
3100
    parse_meta_type(p, &m1->type, &m1->index, &p);
3101

    
3102
    if (m->type == 'g' || m1->type == 'g')
3103
        metadata_global_autocopy = 0;
3104
    if (m->type == 's' || m1->type == 's')
3105
        metadata_streams_autocopy = 0;
3106
    if (m->type == 'c' || m1->type == 'c')
3107
        metadata_chapters_autocopy = 0;
3108
}
3109

    
3110
static void opt_map_meta_data(const char *arg)
3111
{
3112
    fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
3113
                    "Use -map_metadata instead.\n");
3114
    opt_map_metadata(arg);
3115
}
3116

    
3117
static void opt_map_chapters(const char *arg)
3118
{
3119
    AVChapterMap *c;
3120
    char *p;
3121

    
3122
    chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
3123
                              nb_chapter_maps + 1);
3124
    c = &chapter_maps[nb_chapter_maps - 1];
3125
    c->out_file = strtol(arg, &p, 0);
3126
    if (*p)
3127
        p++;
3128

    
3129
    c->in_file = strtol(p, &p, 0);
3130
}
3131

    
3132
static void opt_input_ts_scale(const char *arg)
3133
{
3134
    unsigned int stream;
3135
    double scale;
3136
    char *p;
3137

    
3138
    stream = strtol(arg, &p, 0);
3139
    if (*p)
3140
        p++;
3141
    scale= strtod(p, &p);
3142

    
3143
    if(stream >= MAX_STREAMS)
3144
        ffmpeg_exit(1);
3145

    
3146
    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);
3147
    input_files_ts_scale[nb_input_files][stream]= scale;
3148
}
3149

    
3150
static int opt_recording_time(const char *opt, const char *arg)
3151
{
3152
    recording_time = parse_time_or_die(opt, arg, 1);
3153
    return 0;
3154
}
3155

    
3156
static int opt_start_time(const char *opt, const char *arg)
3157
{
3158
    start_time = parse_time_or_die(opt, arg, 1);
3159
    return 0;
3160
}
3161

    
3162
static int opt_recording_timestamp(const char *opt, const char *arg)
3163
{
3164
    recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3165
    return 0;
3166
}
3167

    
3168
static int opt_input_ts_offset(const char *opt, const char *arg)
3169
{
3170
    input_ts_offset = parse_time_or_die(opt, arg, 1);
3171
    return 0;
3172
}
3173

    
3174
static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3175
{
3176
    const char *codec_string = encoder ? "encoder" : "decoder";
3177
    AVCodec *codec;
3178

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

    
3208
static void opt_input_file(const char *filename)
3209
{
3210
    AVFormatContext *ic;
3211
    AVFormatParameters params, *ap = &params;
3212
    AVInputFormat *file_iformat = NULL;
3213
    int err, i, ret, rfps, rfps_base;
3214
    int64_t timestamp;
3215

    
3216
    if (last_asked_format) {
3217
        if (!(file_iformat = av_find_input_format(last_asked_format))) {
3218
            fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3219
            ffmpeg_exit(1);
3220
        }
3221
        last_asked_format = NULL;
3222
    }
3223

    
3224
    if (!strcmp(filename, "-"))
3225
        filename = "pipe:";
3226

    
3227
    using_stdin |= !strncmp(filename, "pipe:", 5) ||
3228
                    !strcmp(filename, "/dev/stdin");
3229

    
3230
    /* get default parameters from command line */
3231
    ic = avformat_alloc_context();
3232
    if (!ic) {
3233
        print_error(filename, AVERROR(ENOMEM));
3234
        ffmpeg_exit(1);
3235
    }
3236

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

    
3250
    set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3251

    
3252
    ic->video_codec_id   =
3253
        find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3254
                          avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3255
    ic->audio_codec_id   =
3256
        find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3257
                          avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3258
    ic->subtitle_codec_id=
3259
        find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3260
                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3261
    ic->flags |= AVFMT_FLAG_NONBLOCK | AVFMT_FLAG_PRIV_OPT;
3262

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

    
3299
    ic->loop_input = loop_input;
3300

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

    
3310
    timestamp = start_time;
3311
    /* add the stream start time */
3312
    if (ic->start_time != AV_NOPTS_VALUE)
3313
        timestamp += ic->start_time;
3314

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

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

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

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

    
3372
                    (float)rfps / rfps_base, rfps, rfps_base);
3373
            }
3374
            /* update the current frame rate to match the stream frame rate */
3375
            frame_rate.num = rfps;
3376
            frame_rate.den = rfps_base;
3377

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

    
3398
    input_files[nb_input_files] = ic;
3399
    input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3400
    /* dump the file content */
3401
    if (verbose >= 0)
3402
        av_dump_format(ic, nb_input_files, filename, 0);
3403

    
3404
    nb_input_files++;
3405

    
3406
    video_channel = 0;
3407

    
3408
    av_freep(&video_codec_name);
3409
    av_freep(&audio_codec_name);
3410
    av_freep(&subtitle_codec_name);
3411
}
3412

    
3413
static void check_inputs(int *has_video_ptr,
3414
                         int *has_audio_ptr,
3415
                         int *has_subtitle_ptr,
3416
                         int *has_data_ptr)
3417
{
3418
    int has_video, has_audio, has_subtitle, has_data, i, j;
3419
    AVFormatContext *ic;
3420

    
3421
    has_video = 0;
3422
    has_audio = 0;
3423
    has_subtitle = 0;
3424
    has_data = 0;
3425

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

    
3456
static void new_video_stream(AVFormatContext *oc, int file_idx)
3457
{
3458
    AVStream *st;
3459
    AVOutputStream *ost;
3460
    AVCodecContext *video_enc;
3461
    enum CodecID codec_id = CODEC_ID_NONE;
3462
    AVCodec *codec= NULL;
3463

    
3464
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3465
    if (!st) {
3466
        fprintf(stderr, "Could not alloc stream\n");
3467
        ffmpeg_exit(1);
3468
    }
3469
    ost = new_output_stream(oc, file_idx);
3470

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

    
3490
    avcodec_get_context_defaults3(st->codec, codec);
3491
    ost->bitstream_filters = video_bitstream_filters;
3492
    video_bitstream_filters= NULL;
3493

    
3494
    st->codec->thread_count= thread_count;
3495

    
3496
    video_enc = st->codec;
3497

    
3498
    if(video_codec_tag)
3499
        video_enc->codec_tag= video_codec_tag;
3500

    
3501
    if(   (video_global_header&1)
3502
       || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3503
        video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3504
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3505
    }
3506
    if(video_global_header&2){
3507
        video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3508
        avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3509
    }
3510

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

    
3521
        video_enc->codec_id = codec_id;
3522
        set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3523

    
3524
        if (codec && codec->supported_framerates && !force_fps)
3525
            fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3526
        video_enc->time_base.den = fps.num;
3527
        video_enc->time_base.num = fps.den;
3528

    
3529
        video_enc->width = frame_width;
3530
        video_enc->height = frame_height;
3531
        video_enc->pix_fmt = frame_pix_fmt;
3532
        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3533
        st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3534

    
3535
        choose_pixel_fmt(st, codec);
3536

    
3537
        if (intra_only)
3538
            video_enc->gop_size = 0;
3539
        if (video_qscale || same_quality) {
3540
            video_enc->flags |= CODEC_FLAG_QSCALE;
3541
            video_enc->global_quality=
3542
                st->quality = FF_QP2LAMBDA * video_qscale;
3543
        }
3544

    
3545
        if(intra_matrix)
3546
            video_enc->intra_matrix = intra_matrix;
3547
        if(inter_matrix)
3548
            video_enc->inter_matrix = inter_matrix;
3549

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

    
3580
        if (do_psnr)
3581
            video_enc->flags|= CODEC_FLAG_PSNR;
3582

    
3583
        /* two pass mode */
3584
        if (do_pass) {
3585
            if (do_pass == 1) {
3586
                video_enc->flags |= CODEC_FLAG_PASS1;
3587
            } else {
3588
                video_enc->flags |= CODEC_FLAG_PASS2;
3589
            }
3590
        }
3591

    
3592
        if (forced_key_frames)
3593
            parse_forced_key_frames(forced_key_frames, ost, video_enc);
3594
    }
3595
    if (video_language) {
3596
        av_metadata_set2(&st->metadata, "language", video_language, 0);
3597
        av_freep(&video_language);
3598
    }
3599

    
3600
    /* reset some key parameters */
3601
    video_disable = 0;
3602
    av_freep(&video_codec_name);
3603
    av_freep(&forced_key_frames);
3604
    video_stream_copy = 0;
3605
    frame_pix_fmt = PIX_FMT_NONE;
3606
}
3607

    
3608
static void new_audio_stream(AVFormatContext *oc, int file_idx)
3609
{
3610
    AVStream *st;
3611
    AVOutputStream *ost;
3612
    AVCodec *codec= NULL;
3613
    AVCodecContext *audio_enc;
3614
    enum CodecID codec_id = CODEC_ID_NONE;
3615

    
3616
    st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3617
    if (!st) {
3618
        fprintf(stderr, "Could not alloc stream\n");
3619
        ffmpeg_exit(1);
3620
    }
3621
    ost = new_output_stream(oc, file_idx);
3622

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

    
3636
    avcodec_get_context_defaults3(st->codec, codec);
3637

    
3638
    ost->bitstream_filters = audio_bitstream_filters;
3639
    audio_bitstream_filters= NULL;
3640

    
3641
    st->codec->thread_count= thread_count;
3642

    
3643
    audio_enc = st->codec;
3644
    audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3645

    
3646
    if(audio_codec_tag)
3647
        audio_enc->codec_tag= audio_codec_tag;
3648

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

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

    
3680
    /* reset some key parameters */
3681
    audio_disable = 0;
3682
    av_freep(&audio_codec_name);
3683
    audio_stream_copy = 0;
3684
}
3685

    
3686
static void new_data_stream(AVFormatContext *oc, int file_idx)
3687
{
3688
    AVStream *st;
3689
    AVOutputStream *ost;
3690
    AVCodec *codec=NULL;
3691
    AVCodecContext *data_enc;
3692

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

    
3707
    data_enc->codec_type = AVMEDIA_TYPE_DATA;
3708

    
3709
    if (data_codec_tag)
3710
        data_enc->codec_tag= data_codec_tag;
3711

    
3712
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3713
        data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3714
        avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3715
    }
3716
    if (data_stream_copy) {
3717
        st->stream_copy = 1;
3718
    }
3719

    
3720
    data_disable = 0;
3721
    av_freep(&data_codec_name);
3722
    data_stream_copy = 0;
3723
}
3724

    
3725
static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3726
{
3727
    AVStream *st;
3728
    AVOutputStream *ost;
3729
    AVCodec *codec=NULL;
3730
    AVCodecContext *subtitle_enc;
3731
    enum CodecID codec_id = CODEC_ID_NONE;
3732

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

    
3753
    ost->bitstream_filters = subtitle_bitstream_filters;
3754
    subtitle_bitstream_filters= NULL;
3755

    
3756
    subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3757

    
3758
    if(subtitle_codec_tag)
3759
        subtitle_enc->codec_tag= subtitle_codec_tag;
3760

    
3761
    if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3762
        subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3763
        avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3764
    }
3765
    if (subtitle_stream_copy) {
3766
        st->stream_copy = 1;
3767
    } else {
3768
        subtitle_enc->codec_id = codec_id;
3769
        set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3770
    }
3771

    
3772
    if (subtitle_language) {
3773
        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3774
        av_freep(&subtitle_language);
3775
    }
3776

    
3777
    subtitle_disable = 0;
3778
    av_freep(&subtitle_codec_name);
3779
    subtitle_stream_copy = 0;
3780
}
3781

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

    
3792
    if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3793
    else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3794
    else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3795
    else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3796
    else av_assert0(0);
3797
    return 0;
3798
}
3799

    
3800
/* arg format is "output-stream-index:streamid-value". */
3801
static int opt_streamid(const char *opt, const char *arg)
3802
{
3803
    int idx;
3804
    char *p;
3805
    char idx_str[16];
3806

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

    
3822
static void opt_output_file(const char *filename)
3823
{
3824
    AVFormatContext *oc;
3825
    int err, use_video, use_audio, use_subtitle, use_data;
3826
    int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3827
    AVFormatParameters params, *ap = &params;
3828
    AVOutputFormat *file_oformat;
3829

    
3830
    if (!strcmp(filename, "-"))
3831
        filename = "pipe:";
3832

    
3833
    oc = avformat_alloc_output_context(last_asked_format, NULL, filename);
3834
    last_asked_format = NULL;
3835
    if (!oc) {
3836
        print_error(filename, AVERROR(ENOMEM));
3837
        ffmpeg_exit(1);
3838
    }
3839
    file_oformat= oc->oformat;
3840

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

    
3856
        /* disable if no corresponding type found and at least one
3857
           input file */
3858
        if (nb_input_files > 0) {
3859
            check_inputs(&input_has_video,
3860
                         &input_has_audio,
3861
                         &input_has_subtitle,
3862
                         &input_has_data);
3863

    
3864
            if (!input_has_video)
3865
                use_video = 0;
3866
            if (!input_has_audio)
3867
                use_audio = 0;
3868
            if (!input_has_subtitle)
3869
                use_subtitle = 0;
3870
            if (!input_has_data)
3871
                use_data = 0;
3872
        }
3873

    
3874
        /* manual disable */
3875
        if (audio_disable)    use_audio    = 0;
3876
        if (video_disable)    use_video    = 0;
3877
        if (subtitle_disable) use_subtitle = 0;
3878
        if (data_disable)     use_data     = 0;
3879

    
3880
        if (use_video)    new_video_stream(oc, nb_output_files);
3881
        if (use_audio)    new_audio_stream(oc, nb_output_files);
3882
        if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3883
        if (use_data)     new_data_stream(oc, nb_output_files);
3884

    
3885
        oc->timestamp = recording_timestamp;
3886

    
3887
        av_metadata_copy(&oc->metadata, metadata, 0);
3888
        av_metadata_free(&metadata);
3889
    }
3890

    
3891
    output_files[nb_output_files++] = oc;
3892

    
3893
    /* check filename in case of an image number is expected */
3894
    if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3895
        if (!av_filename_number_test(oc->filename)) {
3896
            print_error(oc->filename, AVERROR(EINVAL));
3897
            ffmpeg_exit(1);
3898
        }
3899
    }
3900

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

    
3923
        /* open the file */
3924
        if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3925
            print_error(filename, err);
3926
            ffmpeg_exit(1);
3927
        }
3928
    }
3929

    
3930
    memset(ap, 0, sizeof(*ap));
3931
    if (av_set_parameters(oc, ap) < 0) {
3932
        fprintf(stderr, "%s: Invalid encoding parameters\n",
3933
                oc->filename);
3934
        ffmpeg_exit(1);
3935
    }
3936

    
3937
    oc->preload= (int)(mux_preload*AV_TIME_BASE);
3938
    oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3939
    oc->loop_output = loop_output;
3940

    
3941
    set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3942

    
3943
    av_freep(&forced_key_frames);
3944
}
3945

    
3946
/* same option as mencoder */
3947
static int opt_pass(const char *opt, const char *arg)
3948
{
3949
    do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3950
    return 0;
3951
}
3952

    
3953
static int64_t getutime(void)
3954
{
3955
#if HAVE_GETRUSAGE
3956
    struct rusage rusage;
3957

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

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

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

    
4006
static void opt_inter_matrix(const char *arg)
4007
{
4008
    inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4009
    parse_matrix_coeffs(inter_matrix, arg);
4010
}
4011

    
4012
static void opt_intra_matrix(const char *arg)
4013
{
4014
    intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4015
    parse_matrix_coeffs(intra_matrix, arg);
4016
}
4017

    
4018
static void show_usage(void)
4019
{
4020
    printf("Hyper fast Audio and Video encoder\n");
4021
    printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
4022
    printf("\n");
4023
}
4024

    
4025
static void show_help(void)
4026
{
4027
    AVCodec *c;
4028
    AVOutputFormat *oformat = NULL;
4029

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

    
4059
    /* individual codec options */
4060
    c = NULL;
4061
    while ((c = av_codec_next(c))) {
4062
        if (c->priv_class) {
4063
            av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4064
            printf("\n");
4065
        }
4066
    }
4067

    
4068
    av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4069
    printf("\n");
4070

    
4071
    /* individual muxer options */
4072
    while ((oformat = av_oformat_next(oformat))) {
4073
        if (oformat->priv_class) {
4074
            av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4075
            printf("\n");
4076
        }
4077
    }
4078

    
4079
    av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4080
}
4081

    
4082
static void opt_target(const char *arg)
4083
{
4084
    enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4085
    static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4086

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

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

    
4138
    if(!strcmp(arg, "vcd")) {
4139

    
4140
        opt_video_codec("mpeg1video");
4141
        opt_audio_codec("mp2");
4142
        opt_format("vcd");
4143

    
4144
        opt_frame_size(norm == PAL ? "352x288" : "352x240");
4145
        opt_frame_rate(NULL, frame_rates[norm]);
4146
        opt_default("g", norm == PAL ? "15" : "18");
4147

    
4148
        opt_default("b", "1150000");
4149
        opt_default("maxrate", "1150000");
4150
        opt_default("minrate", "1150000");
4151
        opt_default("bufsize", "327680"); // 40*1024*8;
4152

    
4153
        opt_default("ab", "224000");
4154
        audio_sample_rate = 44100;
4155
        audio_channels = 2;
4156

    
4157
        opt_default("packetsize", "2324");
4158
        opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4159

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

    
4168
        opt_video_codec("mpeg2video");
4169
        opt_audio_codec("mp2");
4170
        opt_format("svcd");
4171

    
4172
        opt_frame_size(norm == PAL ? "480x576" : "480x480");
4173
        opt_frame_rate(NULL, frame_rates[norm]);
4174
        opt_default("g", norm == PAL ? "15" : "18");
4175

    
4176
        opt_default("b", "2040000");
4177
        opt_default("maxrate", "2516000");
4178
        opt_default("minrate", "0"); //1145000;
4179
        opt_default("bufsize", "1835008"); //224*1024*8;
4180
        opt_default("flags", "+scan_offset");
4181

    
4182

    
4183
        opt_default("ab", "224000");
4184
        audio_sample_rate = 44100;
4185

    
4186
        opt_default("packetsize", "2324");
4187

    
4188
    } else if(!strcmp(arg, "dvd")) {
4189

    
4190
        opt_video_codec("mpeg2video");
4191
        opt_audio_codec("ac3");
4192
        opt_format("dvd");
4193

    
4194
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4195
        opt_frame_rate(NULL, frame_rates[norm]);
4196
        opt_default("g", norm == PAL ? "15" : "18");
4197

    
4198
        opt_default("b", "6000000");
4199
        opt_default("maxrate", "9000000");
4200
        opt_default("minrate", "0"); //1500000;
4201
        opt_default("bufsize", "1835008"); //224*1024*8;
4202

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

    
4206
        opt_default("ab", "448000");
4207
        audio_sample_rate = 48000;
4208

    
4209
    } else if(!strncmp(arg, "dv", 2)) {
4210

    
4211
        opt_format("dv");
4212

    
4213
        opt_frame_size(norm == PAL ? "720x576" : "720x480");
4214
        opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4215
                          (norm == PAL ? "yuv420p" : "yuv411p"));
4216
        opt_frame_rate(NULL, frame_rates[norm]);
4217

    
4218
        audio_sample_rate = 48000;
4219
        audio_channels = 2;
4220

    
4221
    } else {
4222
        fprintf(stderr, "Unknown target: %s\n", arg);
4223
        ffmpeg_exit(1);
4224
    }
4225
}
4226

    
4227
static void opt_vstats_file (const char *arg)
4228
{
4229
    av_free (vstats_filename);
4230
    vstats_filename=av_strdup (arg);
4231
}
4232

    
4233
static void opt_vstats (void)
4234
{
4235
    char filename[40];
4236
    time_t today2 = time(NULL);
4237
    struct tm *today = localtime(&today2);
4238

    
4239
    snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4240
             today->tm_sec);
4241
    opt_vstats_file(filename);
4242
}
4243

    
4244
static int opt_bsf(const char *opt, const char *arg)
4245
{
4246
    AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4247
    AVBitStreamFilterContext **bsfp;
4248

    
4249
    if(!bsfc){
4250
        fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4251
        ffmpeg_exit(1);
4252
    }
4253

    
4254
    bsfp= *opt == 'v' ? &video_bitstream_filters :
4255
          *opt == 'a' ? &audio_bitstream_filters :
4256
                        &subtitle_bitstream_filters;
4257
    while(*bsfp)
4258
        bsfp= &(*bsfp)->next;
4259

    
4260
    *bsfp= bsfc;
4261

    
4262
    return 0;
4263
}
4264

    
4265
static int opt_preset(const char *opt, const char *arg)
4266
{
4267
    FILE *f=NULL;
4268
    char filename[1000], tmp[1000], tmp2[1000], line[1000];
4269
    char *codec_name = *opt == 'v' ? video_codec_name :
4270
                       *opt == 'a' ? audio_codec_name :
4271
                                     subtitle_codec_name;
4272

    
4273
    if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4274
        fprintf(stderr, "File for preset '%s' not found\n", arg);
4275
        ffmpeg_exit(1);
4276
    }
4277

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

    
4301
    fclose(f);
4302

    
4303
    return 0;
4304
}
4305

    
4306
static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4307
{
4308
}
4309

    
4310
static void opt_passlogfile(const char *arg)
4311
{
4312
    pass_logfilename_prefix = arg;
4313
    opt_default("passlogfile", arg);
4314
}
4315

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

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

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

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

    
4431
    /* grab options */
4432
    { "vc", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4433
    { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4434
    { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4435

    
4436
    /* muxer options */
4437
    { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4438
    { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4439

    
4440
    { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4441
    { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4442
    { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4443

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

    
4451
    { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4452
    { NULL, },
4453
};
4454

    
4455
int main(int argc, char **argv)
4456
{
4457
    int64_t ti;
4458

    
4459
    av_log_set_flags(AV_LOG_SKIP_REPEATED);
4460

    
4461
    if(argc>1 && !strcmp(argv[1], "-d")){
4462
        run_as_daemon=1;
4463
        verbose=-1;
4464
        av_log_set_callback(log_callback_null);
4465
        argc--;
4466
        argv++;
4467
    }
4468

    
4469
    avcodec_register_all();
4470
#if CONFIG_AVDEVICE
4471
    avdevice_register_all();
4472
#endif
4473
#if CONFIG_AVFILTER
4474
    avfilter_register_all();
4475
#endif
4476
    av_register_all();
4477

    
4478
#if HAVE_ISATTY
4479
    if(isatty(STDIN_FILENO))
4480
        avio_set_interrupt_cb(decode_interrupt_cb);
4481
#endif
4482

    
4483
    init_opts();
4484

    
4485
    show_banner();
4486

    
4487
    /* parse options */
4488
    parse_options(argc, argv, options, opt_output_file);
4489

    
4490
    if(nb_output_files <= 0 && nb_input_files == 0) {
4491
        show_usage();
4492
        fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4493
        ffmpeg_exit(1);
4494
    }
4495

    
4496
    /* file converter / grab */
4497
    if (nb_output_files <= 0) {
4498
        fprintf(stderr, "At least one output file must be specified\n");
4499
        ffmpeg_exit(1);
4500
    }
4501

    
4502
    if (nb_input_files == 0) {
4503
        fprintf(stderr, "At least one input file must be specified\n");
4504
        ffmpeg_exit(1);
4505
    }
4506

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

    
4517
    return ffmpeg_exit(0);
4518
}